C++继承和派生笔记

继承和派生

class Student:public Person

派生类把基类全部的成员（不包括构造函数和解析函数）继承下来

公有继承

基类成员继承给派生类后，其访问权限不变，但基类成员的私有成员在派生类中不可以直接访问

私有继承

基类中的所有成员都以私有成员身份出现在派生类中，基类的私有成员在派生类中不可直接访问

保护成员和保护继承

从用户的角度来看，保护成员等价于私有成员，但是有一点不同，保护成员可以被派生类的成员函数使用

在保护继承中，基类的公有和保护成员都以保护成员的身份出现在派生类中，而基类的私有成员不可以直接访问

派生类的构造函数

class Person
{
public:Person(){id = 1;name = "";sex = 'L';}Person(int id,string name,char sex){this->id = id;this->name = name;this->sex = sex;}
private:int id;string name;char sex;
};class Student:public Person
{   // 在派生类构造函数的形参列表中，要给出初始化基类和派生类的数据成员所需要的全部参数  Student(int id,string name,char sex,float score):Person(id,name,sex){this->score = score;}
privatefloat score;
};

当创建一个派生类的对象时，系统首先自动调用基类构造函数，再调用派生类的构造函数。

如果一个类只作为基类使用，一般不会用于实例化对象，就会把这个基数的数据成员和构造函数设置为protected访问权限，这样既保证了数据的封装性，又能在派生类中访问，保证了数据的一致性。

派生类的析构函数

先执行派生类的析构函数，然后调用基类的析构函数。

多继承

#include<iostream>
using namespace std;
class A
{
public:A(int x){this->x = x;}
private:int x;};
class B
{
public:B(int y){this->y = y;}
private:int y;
};class C:public A,public B
{
public:C(int x,int y,int z):A(x),B(y){this->z = z;}
private:int z;}

同名函数的屏蔽：

如果派生类和基类的函数同名，但是参数不同，此时，无论有没有virtual关键字，基类函数被隐藏。

如果函数同名，参数相同，并且无virtual关键字，基类函数被隐藏。（注意和函数重写的区别）

采用：“对象名.基类名：：成员名”唯一访问函数

多继承的时候可能会产生二义性问题。c++提供虚基类的方法，当基类通过多个路径被一个派生类继承时，该派生类只继承该基类一次。

class A:virtual public M

类的组合

继承时纵向的，组合是横向的。

#include<iostream>
using namespace std;
class Point
{public:Point():x(0),y(0){cout<<"Point's default constructor was called"<<endl;}Point(double x,double y):x(x),y(y){cout<<"Point's constructor was called"<<endl;}Point(Point &p){x = p.x;y = p.y;cout<<"Point's copyConstructor was called"<<endl;}
private:double x;double y;
};class Line
{
public:Line():A(),B(){}Line(double x1,double y1,double x2,double y2):A(x1,y1),B(x2,y2){}Line(Point p1,Point p2):A(p1),B(p2){}
Private:Point A;Point B;
};

基类和派生类的转换

不能把一个整形数据赋值给指针变量

可以用派生类对象对基类对象进行赋值，并且具有赋值兼容性（公有继承）

多态性与虚函数

虚函数

满足的条件：

基类与子类之间为公有继承方式
基类函数要声明为虚函数
通过基类指针或者引用来调用函数

class A
{
public:virtual void display{}
};
class B:public A
{
public:void display{}
}void main()
{A *pa;B ba;pa = &ba;pa->display();// 虽然pa是A类的对象，但是执行的是B类的display()
}

在运行过程中，根据基类指针指向不同的派生类对象就可以访问响应对象的虚函数，从而实现了运行时的动态多态性。派生类的虚函数重写或者覆盖了基类的同名虚函数。

注意

virtual关键字只能出现在虚函数的原型声明中，在虚函数的实现中不能出现。
将基类中的某一个成员声明为虚函数后，派生类中的同名函数（函数名相同，参数列表完全一样，返回值类型相同）自动成为虚函数。
如果声明了某个成员函数为虚函数，则在该类中不能出现同名函数（函数名相同，参数列表完全一样，返回值类型相同），在以该类为基类的派生类中，也不能出现同名函数。
非类的成员函数不能定义为虚函数，类的成员函数中静态成员函数和构造函数不能定义为虚函数，当可以将析构函数定义为虚函数。
声明虚函数的时候，必须实现函数体。
当通过基类指针删除指向子类的动态对象时，子类的析构函数没有被执行，说明子类对象动态分配的空间没有得到释放，造成了内存泄露。为解决这个问题，常常将基类的析构函数定义为虚函数。

纯虚函数

virtual void Area(); //错误，必须在基类中实现
virtual void Area()
{
}
//正确
virtual void Area() = 0;
//纯虚函数

抽象类

不用实例化对象，只作为一种“模板”用于派生的类，成为抽象类。

运算符重载

A operate+ (A &a1,A &a2)
{int x = a1.x + a2.x;A a(x);return a;}
//定义一种新的加法算法

一般来说，重载函数中要用到一些private的变量，所以一般把重载函数定义为友元函数。

friend A operate+ (A &a1,A &a2);

有两个实例！！