【C++】继承，菱形继承，虚拟继承，组合详解

coder林宇恒

已于 2024-09-29 19:04:41 修改

阅读量1k

点赞数 11

分类专栏： C++ 文章标签： c++

于 2024-09-28 20:43:59 首次发布

本文链接：https://blog.csdn.net/m0_71164215/article/details/142610544

版权

C++ 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

1. 继承概念与定义

1.1 概念

1. 继承：保持原有类特性的基础上进行扩展，增加功能，这样产生新的类(派生类)，本质是类的复用。

2. 子类会继承父类的成员变量和成员函数。
class Person
{
public:
     void Print()
     {
        ...
     }

protected:
     string _name = "peter"; // 姓名
     int _age = 18;  // 年龄
};

class Student : public Person
{
protected:
     int _stuid; // 学号
};

class Teacher : public Person
{
protected:
     int _jobid; // 工号
};

int main()
{
     Student s;
     Teacher t;
     s.Print();
     t.Print();
     return 0;
}

1.2 定义

【格式】

【继承方式】

1. 有三种继承方式。

【继承后成员访问限定符的变化】

1. 父类私有成员继承后子类不可见不可用，无论子类类内类外。

2. 父类公有或保护成员继承后与继承方式比较，谁小就是谁，public > protected > private。

3. 父类的保护成员，类外不能访问，但是可以继承给子类类内访问。

2. 父类与子类的赋值规则

1. 子类可以赋值给父类/父类指针/父类引用。

2. 父类不可以赋值给子类。

3. public继承中，子类可以看作是一个特殊的父类，is-a的关系。
class Person
{
protected :
    string _name; // 姓名
    string _sex;  // 性别
    int _age; // 年龄
};

class Student : public Person
{
public :
     int _No ; // 学号
};

void Test ()
{
 Student s;
 
 Person p = s;
 Person* pp = &s; //指向子类的父类部分
 Person& rp = s; //父类部分的引用
}

3. 继承的作用域

1. 父类和子类都有自己的独立作用域。

2. 父类和子类允许有同名成员，默认访问子类的，因为隐藏了父类的同名成员，想访问父类的同名成员使用基类::基类成员显示访问。
class Person
{
protected :
     int _num = 111;   
};

class Student : public Person
{
public:
     void Print()
     {
         cout << Person::_num << endl; //显示访问父类
         cout << _num << endl; //默认访问子类同名
     }

protected:
     int _num = 999; 
};
【注意】

1. 重载必须是相同作用域。

2. 成员函数的函数名相同就会构成隐藏。
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;
     }
};

4. 子类的默认成员函数

1. 我们把子类的成员变量看作三部分，内置类型，自定义类型，继承的父类成员变量，把继承的父类看作一个整体。

2. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员，子类变量的构造自己实现。

3. 子类的拷贝构造同理，派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化，自己实现子类的拷贝构造。

4. 派生类的operator=必须要调用基类的operator=完成基类的复制。

5. 子类的析构函数结束后会自动调用父类的析构函数，析构的顺序是先子后父，因为先父后子的子可能会访问父。
//父类
class Person
{
public:
     //父类构造
     Person(const char* name = "peter")
     : _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 ;
     }
        
     //父类析构    
     ~Person()
     {
         cout<<"~Person()" <<endl;
     }

protected:
     string _name; // 姓名
};

//子类
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)
     {
         cout<<"Student(const Student& s)" <<endl ;
     }
     
     //子类赋值重载   
     Student& operator=(const Student& s)
     {
         cout<<"Student& operator= (const Student& s)"<< endl;
         if (this != &s)
         {
             Person::operator=(s); //这里显示调用因为构成了隐藏
             _num = s._num;
         }
         return *this ;
     } 
     
     //子类析构   
     ~Student() 
     {
         cout<<"~Student()" <<endl;
     }

protected:
     int _num ; //学号
};

5. 继承与友元

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

6. 继承与静态成员

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

2. 父类的静态成员不属于某个对象，属于整个类，继承的子类也有使用权。

7. 菱形继承

7.1 继承关系

【单继承】

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

【多继承】

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

【菱形继承】

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

7.2 菱形继承的问题

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。

在Assistant的对象中Person成员会有两份。

1. 两个_name会造成数据二义性，这个可以显示调用解决。

2. 数据冗余无法解决。
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 ; // 主修课程
};

7.3 虚拟继承

1. 虚拟继承可以解决菱形继承的二义性和数据冗余的问题。

2. vircual关键字要加在继承冗余的类的位置，比如这里冗余的是person类，那么谁继承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 ; // 主修课程
};
【原理】

1. 冗余的变量会被放到最下面。

2. 原本的位置变成一个地址，这个地址指向一张表(虚基表)，表里有这个冗余变量的偏移量，通过偏移量可以找到它。

8. 继承与组合

1. public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。

2. 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

3. 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

4. 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复(black-box reuse)，因为对象的内部细节是不可见的。组合类之间没有很强的依赖关系，耦合度低。
//组合
class A
{
public:
    int _a;
}

class B 
{
private:
    A a;
}

9. 选择题

下面程序输出结果是什么?
class A
{
public:
     A(char *s) { cout<<s<<endl; }
     ~A(){}
};

class B:virtual public A
{
public:
     B(char *s1,char*s2)
     :A(s1) 
     { cout<<s2<<endl; }
};

class C:virtual public A
{
public:
     C(char *s1,char*s2)
     :A(s1)
     { cout<<s2<<endl; }
};

class D:public B,public C
{
public:
     D(char *s1,char *s2,char *s3,char *s4)
     :B(s1,s2),C(s1,s3),A(s1) 
     { cout<<s4<<endl;}
};

int main() 
{
     D *p=new D("class A","class B","class C","class D");
     delete p;
     return 0;
}
【解析】

1. 虚拟继承意味着A只有一份，所以只用初始化一次。

2. 继承的顺序等于声明的顺序等于初始化列表的顺序。

答案是class A，class B，class C，class D。