可见，直接显式调用父类的成员变量是不对的，因此我们必须通过让父类的构造函数将派生下来的成员变量构造初始化，即谁的变量由谁构造。

class Student : public Person
{
public:Student(const char* name, int num=18)//构造函数:Person(name), _num(num){cout << "Student()" << endl;}
protected:int _num; //学号
};

这样就符合C++的规则了。

4.2 派生类的拷贝构造函数

接着上段构造函数的代码，如果不写拷贝构造，编译器会默认生成：

对于拷贝构造，我们需要拷贝构造的有三部分：基类继承下来的类型、内置类型、自定义类型。如果不写拷贝构造，完全可以解决基类继承下来的和内置类型，因为属于基类的类型会自动调用基类的拷贝构造，上面的结果也可以证实这一点，而内置变量的拷贝构造会随着初始化列表进行值拷贝，因此不写拷贝构造的结果与类和对象中的情况是一样的。

但是自己写拷贝构造函数也是必要的，因为会有自定义类型的成员变量，下面就来写一下：

class Student : public Person
{
public:Student(const char* name, int num=18)//构造函数:Person(name), _num(num){cout << "Student()" << endl;}Student(const Student& s)//拷贝构造函数:Person(s),_num(s._num){}
protected:int _num; //学号
};

我们发现，这与构造函数几乎是一样的，此外，对于Person(s)这里发生的就是上述所说的切片赋值。

4.3 派生类的赋值运算符重载

不写这个函数调用默认的赋值运算符重载，情况和拷贝构造一样，成员变量中含自定义变量则不能处理。

class Student : public Person
{
public:Student(const char* name, int num=18)//构造函数:Person(name), _num(num){cout << "Student()" << endl;}Student(const Student& s)//拷贝构造:Person(s), _num(s._num){}Student& operator=(const Student& s){if (this != &s){Person::operator=(s);//注意是Person，避免隐藏_num = s._num;}return *this;}
protected:int _num; //学号
};

赋值运算符重载这里需要注意的就是防止同名造成基类的operator隐藏。

赋值前：

赋值后：

终止：

总结： 实现了上述三个默认成员函数，便发现，只要是基类继承下来的成员变量，那就用基类的构造函数代替显式的构造就可以了，此外就是需要注意同名隐藏的问题，除了这些，派生类的默认成员函数与之前在类和对象中的默认成员函数毫无区别。那就只剩下的派生类的析构函数了。

4.4 派生类的析构函数

如果按照正常的逻辑写析构函数，会发生报错：

这是析构函数与前三者的不同，如果加上作用域，就不会发生错误：

class Student : public Person
{
public:Student(const char* name, int num)//构造函数:Person(name), _num(num){cout << "Student()" << endl;}Student(const Student& s)//拷贝构造:Person(s), _num(s._num){}Student& operator=(const Student& s){if (this != &s){Person::operator=(s);//注意是Person，避免隐藏_num = s._num;}return *this;}~Student()//析构{Person::~Person();}
protected:int _num; //学号
};
int main()
{Student a("张三");return 0;
}

1. 子类析构函数和父类析构函数构成隐藏关系。（由于多态需求关系，所有析构函数都会特殊处理成destructor的函数名，这样由于函数名相同就会发生隐藏）

通过结果发现，析构调用了两次，因此一旦成员变量有new出来的指针，并且析构中写delete p[]的话，就会导致new出来的一块空间析构两次，这样是错误的。因此，析构这里也需要与前三部分的不同：析构不需要像前三个一样显示调用对应的基类的析构函数，而是会自动生成基类的析构函数。因此，不必在派生类的析构函数中调用基类的析构，而是会自动生成。

class Student : public Person
{
public:Student(const char* name, int num = 18)//构造函数:Person(name), _num(num){cout << "Student()" << endl;}Student(const Student& s)//拷贝构造:Person(s), _num(s._num){}Student& operator=(const Student& s){if (this != &s){Person::operator=(s);//注意是Person，避免隐藏_num = s._num;}return *this;}~Student()//析构{//Person::~Person();//不用调用cout << "~Student()" << endl;}
protected:int _num; //学号
};
int main()
{Student a("张三");return 0;
}

2. 发现顺序：

构造： 基类先构造，派生类后构造。

析构： 派生类先析构，基类后析构。

4.5 总结

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。
7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

五.继承与友元

• 核心关系：友元关系不能继承。 也就是说基类友元不能访问子类私有和保护成员

class Student;//前置声明
class Person
{
public:friend void Display(const Person& p, const Student& s);
protected:string _name; // 姓名
};
class Student : public Person
{
protected:int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._stuNum << endl;
}
int main()
{Person p;Student s;Display(p, s);return 0;
}

发现，经过上面的解释，Display并不属于Student类的友元，因此这样是错的。因此，需要将Display同时作为两个类的友元，这样才不会出错：

class Student;
class Person
{
public:friend void Display(const Person& p, const Student& s);
protected:string _name; // 姓名
};
class Student : public Person
{
public:friend void Display(const Person& p, const Student& s);
protected:int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{cout << p._name << endl;cout << s._stuNum << endl;
}
int main()
{Person p;Student s;Display(p, s);return 0;
}

六.继承与静态成员

6.1 静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。 无论派生出多少个子类，都只有一个static成员实例 。

class Person
{
public:Person() { ++_count; }string _name; // 姓名
public:static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:int _stuNum; // 学号
};
class Graduate : public Student
{
protected:string _seminarCourse; // 研究科目
};
//静态成员属于整个类，所有对象，同时也属于所有派生类及对象
int main()
{Person p;Student s;Graduate g;p._name = "张三";s._name = "李四";p._count++;s._count++;cout << p._count << endl;cout << s._count << endl;cout << &p._count << endl;cout << &s._count << endl;cout << Person::_count << endl;cout << Student::_count << endl;cout << Graduate::_count << endl;return 0;
}

6.2 确定是否为解引用

class Person
{
public:Person() { ++_count; }void Print(){cout << "Print" << endl;}string _name; // 姓名
public:static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:int _stuNum; // 学号
};
//静态成员属于整个类，所有对象，同时也属于所有派生类及对象
int main()
{//->和*不一定就是解引用Person* ptr = nullptr;ptr->_count++;//cout << ptr->_name << endl;//1. noptr->Print();//2. yescout << ptr->_count << endl;//3. yes(*ptr).Print();//4.yescout << (*ptr)._count << endl;//5.yesreturn 0;
}

这在this指针中讲过，第一个不对的原因是_name作为成员变量，那么对于成员变量，->或者(*ptr)一定是解引用，由于是空指针，一定会报错。而Print作为成员函数，其不在类中而是在代码段，因此算不上解引用，_count作为静态变量在静态区不在类中当然也算不上解引用。（下面通过反汇编也可以看出）

即在对象中存储就属于解引用，否则不属于。

七.复杂的菱形继承及菱形虚拟继承

7.1 单继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

7.2 多继承

对于Java，只有单继承，没有多继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

7.3 菱形继承

菱形继承：菱形继承是多继承的一种特殊情况。

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在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; // 主修课程
};int main()
{Assistant a;a._name;//出错：二义性return 0;
}

空间角度：数据冗余；从逻辑上：二义性。这两种问题实际上也都可以解决。

解决数据冗余与二义性：

int main()
{Assistant a;//指定作用域a.Student::_name = "张三";a.Teacher::_name = "张老师";return 0;
}

通过指定作用域的方式，就可以解决二义性的问题。即以学生的身份他叫张三，以老师的身份它叫做张老师。

但指定作用域没有彻底解决这个问题，因为这样就是将二义性的东西彻底分开，即如上的地址不同，对象就不同。那如何彻底解决呢？这就涉及到了虚继承。

7.4 菱形虚拟继承

提到虚拟继承，就多了一个关键字：virtual

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

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; // 主修课程
};int main()
{Assistant a;a._name = "小张";a.Student::_name = "张三";a.Teacher::_name = "张老师";cout << &a._name << endl;cout << &a.Student::_name << endl;cout << &a.Teacher::_name << endl;return 0;
}

这样，他们代表的都是同一个变量，通过地址也可以看出：

7.5 虚拟继承解决数据冗余和二义性的原理

如果是普通的菱形继承，像这样：

class A
{
public:int _a;
};
class B : public A
{
public:int _b;
};
class C : public A
{
public:int _c;
};
class D : public B, public C
{
public:int _d;
};
int main()
{D d;d._b = 1;d._c = 2;d._d = 3;d.B::_a = 4;d.C::_a = 5;return 0;
}

我们知道这样会造成二义性和代码冗余，并且通过监视窗口了解数据，然而监视窗口是优化后的，并不能直接看到原始的内存分配，因此下面打开内存窗口观察：

整体都作为D类的数据，D类继承了A、B、C，由于菱形继承的代码冗余，发现B和C继承下来的A都存在在D中，而虚拟继承为了解决两个A同时出现，采用了以下的策略：（下面改成虚拟继承的代码）

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 = 1;d._c = 2;d._d = 3;d.B::_a = 4;d.C::_a = 5;return 0;
}

再打开内存监视观察：

发现，菱形虚拟继承将普通菱形继承在B和C中的A都消除了，在一个新的位置单开了一个位置存储A，但同时也发现，两个黄色的框的地址代表的是什么我们不知道，所以再开两个窗口看看这个地址存储的是什么东西：

由于是小端16进制，当然需要成对的倒着读。即B中地址指向的大小为20，C中地址指向的大小为12，通过左侧内存已的两段地址相减，正好一一对应，而这两个数字就是举例虚基类对象的偏移量。为什么会有偏移量？如果是相同类的赋值，根本不需要这样的东西，而上面谈到过，将派生类赋值给基类会发生切片，切片就会导致等号两边的对象的成员变量的相对位置会发生变化，由于A地址只有一个，此时如果仍要找到该成员变量的位置，就需要一个数据记录下来之前的相对位置，这样才能通过各种作用域去访问同一个A。

那为什么普通的菱形继承没有这个偏移量呢？因为普通的菱形继承不会优化成一个A，这也就代表每一个A都有一个对应的值，他们并不相同，因此不需要通过各种作用域去访问同一个A，每一个作用域都有属于自己的A。

所以可以看出普通菱形继承和菱形虚拟继承的区别：

• 普通菱形继承无法将多个相同的继承类变成一个，这些类即便成员相同，但存储的值也不同。
• 菱形虚拟继承则是将普通菱形继承的相同的继承的类合并成一个，即便访问方式（即作用域）不同，每一个访问方式也能通过相对偏移量找到相同的A。

那这样看起来，似乎由于偏移量的产生使内存占用更多了？当然不是，如果A占用的内存非常大，此消彼长之下，内存空间的占用就会变小。

八. 继承与组合的区别

下面看看继承与组合的代码方式，这些都是见过的。

1. 继承

class X
{int _x;
};
class Y :public X
{int _y;
};

2.组合

class M
{int _m;
};
class N
{M _mm;//组合int _n;
};

继承和组合都是一种代码复用的方式，但是也有所区别。相对于继承，组合更加的保护复用的成员变量，因为继承可以继承下来public、protect、private(虽然看不到，但还是继承了)；而组合只能在另一个类中使用该类的public，同时，也将继承和组合命名为白箱和黑箱，顾名思义，白箱就是一览无余，而黑箱与白箱恰好相反。因此，在继承和组合都能使用的话，推荐使用组合，因为组合可以更好的保护public以外的成员。

九.继承的总结与反思

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的其他语言都没有多继承，如Java。
3. 继承与组合
   • public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
   • 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
   • 优先使用对象组合，而不是类继承
   • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
   • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
   • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

十.笔试面试题

1. 什么是菱形继承？菱形继承的问题是什么？
2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的
3. 继承和组合的区别？什么时候用继承？什么时候用组合？

答：

1. 多继承中的一种特殊继承，即一个类可能被另一个类以不同的作用域继承多次。菱形继承会导致代码的二义性及空间浪费。

2. 通过virtual将 “菱形继承的腰部” 进行修改，防止腰部以下重复使用相同的类。解决冗余与二义性则通过偏移量的访问方式。

3. 继承与组合就像白箱与黑箱，对于非public，一个一览无余，一个恰好相反。因此，在需要派生类和基类间的依赖关系强时，就用继承。相反就用组合。如果都可以，就优先使用组合。