C++入门11——详解C++继承（菱形继承与虚拟继承）-2-阿里云开发者社区

4.派生类的默认成员函数

在C++入门3——类与对象2（类的6个默认成员函数）中，我们已经学习了类的6个默认成员函数：

“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

1.构造函数

默认构造函数

我们知道，默认生成的构造函数对自定义类型调用它的默认成员函数，而内置类型则不做处理。

与普通类相同，派生类（子类）成员默认生成的构造函数处理机制也分为自定义类型和内置类型。

不同的仅仅是派生类构造函数运行的同时多了一个基类的运行，而基类成员则调用基类的构造函数，即：自己调用自己的构造函数，互不掺和。

class Person
{
public:
  Person(const char* name = "张三")
    : _name(name)
  {
    cout << "父类构造Person()" << endl;
  }
protected:
  string _name; // 姓名
};
 
class Student :Person
{
public:
 
private:
  int _stuid = 2020060410;
};
 
int main()
{
  Student s1;
  return 0;
}

自定义构造函数

现在我要自己定义构造函数：

class Student :Person
{
public:
  Student(const char* name, int id)
    :_name(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
private:
  int _stuid = 2020060410;
};

结果却报错了：

因为我们上面说过了：父子互不掺和，不能用儿子的构造函数去构造父亲，想在儿子这里构造父亲，就必须显示调用父亲的构造函数，所以正确的写法应该是：

class Student :Person
{
public:
  Student(const char* name, int id)
    //:_name(name)//error:说过了互不掺和，不能用儿子的构造函数去构造父亲
    :Person(name)//想在儿子这里构造父亲，就必须显示调用父亲的构造函数
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
private:
  int _stuid = 2020060410;
};

（在这里插播一个小问题：父与子的构造顺序是怎样的呢？是先父后子还是先子后父呢？

答案一定是先父后子的，因为我们在C++入门4——类与对象3（构造函数的类型转换和友元详解）中提到过这个问题：初始化列表初始化的顺序跟出现的顺序无关，跟声明的顺序有关！

所以这里即使将id放在name的前面，结果都是父亲先构造，因为父亲的声明在前，儿子的声明在后！）

2.拷贝构造

默认拷贝构造

知道了构造函数，拷贝构造与构造函数相同：

class Person
{
public:
  Person(const char* name = "张三")
    : _name(name)
  {
    cout << "父类构造Person()" << endl;
  }
  Person(const Person& p)
    : _name(p._name)
  {
    cout << "父类拷贝构造Person(const Person& p)" << endl;
  }
protected:
  string _name; // 姓名
};
 
class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
private:
  int _stuid = 2020060410;
};
 
int main()
{
  Student s1("李四", 20);
  Student s2(s1);
  return 0;
}

自定义拷贝构造

自定义拷贝构造与自定义构造函数相同，也必须显示调用父亲的拷贝构造函数，可是问题来了：

父类的拷贝构造函数要怎么调用呢？怎么把子类当中父类的那部分数据取出来呢？

此处就用到了2.基类和派生类对象赋值转换的知识：按照赋值兼容原则：父类把子类那部分切来赋值过去，代码如下：

class Person
{
public:
  Person(const char* name = "张三")
    : _name(name)
  {
    cout << "父类构造Person()" << endl;
  }
  Person(const Person& p)
    : _name(p._name)
  {
    cout << "父类拷贝构造Person(const Person& p)" << endl;
  }
protected:
  string _name; // 姓名
};
 
class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
  Student(const Student& s)
    :Person(s)
    ,_stuid(s._stuid)
  {
        cout << "子类拷贝构造Student(const Student& s)" << endl;
    }
private:
  int _stuid = 2020060410;
};
 
int main()
{
  Student s1("李四", 20);
  Student s2(s1);
  return 0;
}

3.赋值重载

默认赋值重载与前面两个默认成员函数一样，此处重点注意一下自定义赋值重载：

class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
  Student(const Student& s)
    :Person(s)
    ,_stuid(s._stuid)
  {
        cout << "子类拷贝构造Student(const Student& s)" << endl;
    }
  Student& operator=(const Student& s)
  {
        cout << "子类赋值重载Student& operator=(const Student& s)" << endl;
    if (this != &s)
    {
      operator=(s);
      _stuid = s._stuid;
    }
    return *this;
  }
private:
  int _stuid = 2020060410;
};

发现栈溢出了！

这是什么原因呢？

没错！正是前面3.继承中的作用域 中讲的隐藏问题：父类的operator函数与子类的operator函数名字相同，达成了隐藏条件，所以在此处父类的operator被隐藏了，这里一直调用的都是子类的operator函数，因此才导致了栈溢出！

正确代码：

class Person
{
public:
  Person(const char* name = "张三")
    : _name(name)
  {
    cout << "父类构造Person()" << endl;
  }
  Person(const Person& p)
    : _name(p._name)
  {
    cout << "父类拷贝构造Person(const Person& p)" << endl;
  }
  Person& operator=(const Person& p)
  {
    cout << "父类赋值重载Person operator=(const Person& p)" << endl;
    if (this != &p)
      _name = p._name;
    return *this;
  }
protected:
  string _name; // 姓名
};
 
class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    ,_stuid(id)
  {
        cout << "子类构造Student()" << endl;
    }
  Student(const Student& s)
    :Person(s)
    ,_stuid(s._stuid)
  {
        cout << "子类拷贝构造Student(const Student& s)" << endl;
    }
  Student& operator=(const Student& s)
  {
        cout << "子类赋值重载Student& operator=(const Student& s)" << endl;
    if (this != &s)
    {
      Person::operator=(s);
      _stuid = s._stuid;
    }
    return *this;
  }
private:
  int _stuid = 2020060410;
};
 
int main()
{
  Student s1("李四", 20);
  Student s2(s1);
  Student s3("王五",30);
  s2 = s3;
  return 0;
}

4.析构函数

子类的析构函数与父类的析构函数构成隐藏关系，由于后面多态的原因，析构函数会被特殊处理，函数名都会被处理成destrutor()，为了保证先子后父的析构顺序，父类的析构会在子类的析构后自动调用。

class Student :Person
{
public:
  Student(const char* name, int id)
    :Person(name)
    , _stuid(id)
  {
    cout << "子类构造Student()" << endl;
  }
  Student(const Student& s)
    :Person(s)
    , _stuid(s._stuid)
  {
    cout << "子类拷贝构造Student(const Student& s)" << endl;
  }
  Student& operator=(const Student& s)
  {
    cout << "子类赋值重载Student& operator=(const Student& s)" << endl;
    if (this != &s)
    {
      Person::operator=(s);
      _stuid = s._stuid;
    }
    return *this;
  }
  ~Student()
  {
    //Person::~Person();
    cout << "子类析构函数~Student()" << endl;
  }
private:
  int _stuid = 2020060410;
};

（再插播一个小问题：前面说了构造是先父后子，这里的析构确是先子后父，这是为什么呢？

假设析构函数也是先父后子，那么父类资源先被清理释放了，我子类又要去访问父类的资源，就会存在野指针等风险）

总结：

1. 子类的构造函数必须调用父类的构造函数初始化基类的那一部分成员。如果父类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用；

2. 子类的拷贝构造函数必须调用父类的拷贝构造完成父类的拷贝初始化。

3. 子类的operator=必须要调用父类的operator=完成父类的复制。

4. 子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员。因为这样才能保证子类对象先清理子类成员再清理父类成员的顺序。

5. 子类对象初始化先调用父类构造再调用子类构造。

6. 子类对象析构清理先调用子类析构再调父类的析构。

7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后续再详细探究)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

5.继承中的友元与静态成员

5.1继承与友元

这里就一句话：

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

通俗点说，爸爸的朋友不是你的朋友，你如果也想跟爸爸的朋友做朋友，就需要爸爸引荐。

5.2继承与静态成员

这里也只有一句话：

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

根据这个性质，我们就可以统计这个继承体系中一共出现了多少个对象：

class Person
{
public:
  Person() 
  { 
    ++_count;
  }
protected:
  string _name; // 姓名
public:
  static int _count; // 统计人的个数。
};
int Person::_count = 0;
 
class Student :public Person
{
protected:
  int _stuid;
};
 
int main()
{
  Student s1;
  Student s2;
  Student s3;
  Student s4;
  cout << "人数：" << Person::_count << endl;
  return 0;
}

*6.复杂的菱形继承及菱形虚拟继承

6.1单继承与多继承

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

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

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

6.2菱形继承的问题

C++中多继承的初衷显然是好的，它希望一个类可以同时拥有两个类的功能。

class Person
{
public:
  string _name;
  int _age;
};

class Student:public Person
{
protected:
  int _stuid;
};
 
class Teacher :public Person
{
protected:
  int _tecid;
};

class Schoool :public Student, public Teacher
{
protected:
  string address;
};

可是这么做也存在一定的问题：有了多继承就有可能出现上面所说的菱形继承，比如：School对象中Person的成员会有两份：

int main()
{
  School x1;
  //x1._name = "王五";//error："School::_name" 不明确
  x1.Student::_name = "张三";
  x1.Teacher::_name = "张老师";
  return 0;
}

需要显示指定访问哪个父类的成员可以解决二义性问题，我在学生里面叫张三，在老师里面叫张老师，显示指定访问哪个父类就解决了二义性问题，但是我的年龄呢？电话呢？家庭住址呢？这些数据总是唯一的吧，我们在两个类分别存一个，这虽然暂时解决了二义性问题，可终归治标不治本，这样做又会导致数据的冗余。

如何解决这个问题呢？

6.3虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余问题。如上面的继承关系，在Student和 Teacher继承Person时使用虚拟继承(virtual)，即可解决问题。

具体用法如下：

class Person
{
public:
  string _name;
  int _age;
};
 
class Student :virtual public Person
{
protected:
  int _stuid;
};
 
class Teacher :virtual public Person
{
protected:
  int _tecid;
};
 
class School :public Student, public Teacher
{
protected:
  string address;
};
 
int main()
{
  School x1;
  x1._name = "王五";
  return 0;
}

7.C++11中的final关键字

有这样一个问题：让你实现一个类，使这个类不能被继承？

方法1：将这个类的构造函数私有化：

class A
{
public:
protected:
  int _a;
private:
  A()
  {
 
  }
};
 
class B :public A
{
 
};

这样写程序不会报错，可是我们实例化子类对象时情况就不对了：

int main()
{
  B bb;
  return 0;
}

因为派生类的构造必须先去调用基类的构造，可是基类的构造被private了，所以派生类自然而然实例不出对象。

方法2：C++11中增加final，final修饰的类为最终类，不能被继承

方法1那样的做法可以达到目的，可是只有在实例化子类对象时才会报错，于是C++11就引入了final：

class A final
{
public:
protected:
  int _a;
private:
  A()
  {
 
  }
};
 
class B :public A
{
 
};

（本篇完）

C++入门11——详解C++继承（菱形继承与虚拟继承）-2