C++中的继承
1.概念和定义的方法
继承是面向对象程序设计使代码可以 复用 的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称 派生类（子类） 。我们之前接触的复用都是函数复用，继承是 类 设计层次的复用。
应用方法，如下
class Person
{
public :
void Print ()
{
cout<<_name <当我们使用public继承，我们发现父类的public访问限定符下Print()函数可以直接在类外使用
当我们使用protected和private继承,我们发现父类的public访问限定符下的Print()函数在类外无法再调用了
1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。2. 基类private成员在派生类中是不能被访问，如果 基类成员不想在类外直接被访问，但需要在派生类中能访问 ，就定义为protected。可以看出保护成员限定符是因继承才出现的。3. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。
2.基类（父类）和派生类（子类）对象赋值转换
1.派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用 。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
2.基类对象不能赋值给派生类对象。
3.基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类
的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run-
Time Type Information)的dynamic_cast 来进行识别后进行安全转换。
class Person
{
protected:
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public:
int _No; // 学号
};
void Test()
{
Student s;
// 1.子类对象可以赋值给父类对象/指针/引用
Person p = s;
Person* pp = &s;
Person& rp = s;
//2.基类对象不能赋值给派生类对象
s = p;
}
int main()
{
Test();
return 0;
}3.继承中的作用域
1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。
我们看如下：
class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
//A::fun();
cout << "func(int i)->" << i << endl;
}
};
void Test()
{
B b;
b.fun(10);//会调用谁的？
};
int main()
{
Test();
return 0;
}
我们发现调用的是子类的函数，这时因为 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。那我们如何调用父类函数呢？可以在子类成员函数中，可以使用 基类::基类成员 显示访问。
4.派生类的默认成员函数
1. 派生类的 构造函数必须调用基类的构造函数初始化基类的那一部分成员 。如果基类没有默认的构造函数，则必须在 派生类 构造函数的 初始化列表阶段显示调用 。
2. 派生类 的 拷贝构造函数 必须 调用基类的拷贝构造 完成 基类的拷贝初始化 。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类的析构函数会在被调用完成后 自动调用 基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象 初始化 先调用基类构造再调派生类构造。
6. 派生类对象 析构 清理 先调用派生类 析构 再调基类 的析构。
5.多继承
单继承：一个子类只有一个直接父类时称这个继承关系为单继承
多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
菱形继承：菱形继承是多继承的一种特殊情况
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有 数据冗余 和 二义性 的问题。
在 Assistant 的对象中 Person 成员会有两份。
class Person
{
public:
string _name; // 姓名
};
class Student : public Person
{
protected:
int _num; //学号
};
class Teacher : public Person
{
protected:
int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
string _majorCourse; // 主修课程
};
void Test1()
{
cout << "Student的大小：" << sizeof(Student) << endl;
cout << "Teacher的大小：" << sizeof(Teacher) << endl;
cout << "Assistant的大小：" << sizeof(Assistant) << endl;
这样会有二义性无法明确知道访问的是哪一个
//Assistant a;
//a._name = "peter";
需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
//a.Student::_name = "xxx";
//a.Teacher::_name = "yyy";
}
int main()
{
Test1();
return 0;
}
可以看出在Assistant的对象中Person成员会有两份
6.虚拟继承
那我们如何解决菱形继承有数据冗余和二义性的问题呢？
虚拟继承 可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在 Student 和
Teacher 的继承 Person 时使用 virtual虚拟继承
class Person
{
public :
string _name ; // 姓名
};
class Student : virtual public Person
{
protected :
int _num ; //学号
};
class Teacher : virtual public Person
{
protected :
int _id ; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected :
string _majorCourse ; // 主修课程
};
void Test ()
{
Assistant a ;
a._name = "peter";
} 虚拟继承解决数据冗余和二义性的原理
class A
{
public:
int _a;
};
class B : virtual public A
{
public:
int _b;
};
class C : virtual public A
{
public:
int _c;
};
class D : public B, public C
{
public:
int _d;
};
int main()
{
D d;
d.B::_a = 1;
d.C::_a = 2;
d._b = 3;
d._c = 4;
d._d = 5;
return 0;
}
我们不使用虚拟继承可以看到数据冗余
我们使用虚拟继承来看看
这里是通过了 B 和 C 的两个指针，指 向的一张表。这两个指针叫 虚基表指针 ，这两个表叫 虚基表 。虚基表中存的 偏移量 。通过偏移量 可以找到下面的 A 。
