【C++】继承 -- 详解（下）-阿里云开发者社区

【C++】继承 -- 详解（上）https://developer.aliyun.com/article/1514706?spm=a2c6h.13148508.setting.19.4b904f0ejdbHoA

五、继承与友元

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

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;
}

六、继承与静态成员

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

//无论继承多少层，大家用的始终是同一个变量
 
// 基类
class Person
{
public :
    Person () {++ _count ;}
protected :
    string _name ; // 姓名
public :
    static int _count; // 统计人的个数
};
 
int Person :: _count = 0;
class Student : public Person
{
protected :
    int _stuNum ; // 学号
};
 
class Graduate : public Student
{
protected :
    string _seminarCourse ; // 研究科目
};
 
void TestPerson()
{
    Student s1 ;
    Student s2 ;
    Student s3 ;
    Graduate s4 ;
    cout << " 人数 :" << Person ::_count << endl;
    Student ::_count = 0;
    cout << " 人数 :" << Person ::_count << endl;
}

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

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

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

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 = "Peter";
    // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
 
    return 0;
}

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

如上面的继承关系，在 Student 和 Teacher 的继承 Person 时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

注意：virtual 不是在 Assistant 处加，而是在菱形中间腰部 (Student 和 Teacher) 的位置加。

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 = "Peter"; //这个时候_name其实只有一个
 
    // 这下面两个显示访问其实访问的都是一个变量
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
 
    return 0;
}

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

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助内存窗口观察对象成 员的模型。

class A
{
public:
    int _a;
};
 
// class B : public A
class B : virtual public A
{
public:
    int _b;
};
 
// class C : public A
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;
}

下图是菱形继承的内存对象成员模型：这里可以看到数据冗余。

下图是菱形虚拟继承的内存对象成员模型：这里可以分析出 D 对象中将 A 放到的了对象组成的最下面，这个 A 同时属于 B 和 C，那么 B 和 C 如何去找到公共的 A 呢？

这里是通过了 B 和 C 的两个指针，指向的一张表，这张表是什么呢？

B 和 C 中还各自多了 4 个字节的地址，我们再通过其它内存窗口查看 B 和 C 中那两个地址放的到底是什么，发现 B 和 C 中各自那所谓多余的 4 个字节指向的空间中存储了十进制：20（十六进制：14 00 00 00）和十进制：12（十六进制：0c 00 00 00），其实它们一点都不多余，其代表的含义是对于 A 的偏移量 —— 0x005EF75C + 20 = 0x005EF770；0x005EF764 + 14 = 0x005EF770；，官方来讲对于 0x005EF75C 和 0x005EF764 所指向的内存 2 和内存 3，称之为虚基表。

这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的 A。

为什么 D 中 B 和 C 部分要去找属于自己的 A ？那么看看当下面的赋值发生时，d 是不是要去找出 B/C 成员中的 A 才能赋值过去？

D d;
B b;
B* p1 = &d; // B对象指针 -> D对象，把D对象切片给B对象指针
p1->_a;     // 指针访问虚基类A的成员＿ａ
B* p2 = &b; // B对象指针 -> B对象
p2->_a;     // 指针访问虚基类A的成员＿ａ

（1）为什么需要偏移量？

指针是无法识别自己指向的是哪个类的对象，即可能指向自己，也可能指向子类，比如上面这段代码，B 对象和 D 对象中的虚基类成员 _a 的偏移量是不一样的，所以我们也只能通过偏移量来计算出 _a 的位置。

B 或 C 的对象、对象指针、对象引用访问继承的虚基类 A 的对象中的成员 _a，都要取偏移量计算 _a 的位置。

（2）为什么不在 0x005EF75C、0x005EF764 直接存偏移量？

这样也是可以的，但是使用虚基表来存储的原因是：

还有其它场景 —— 在引入多态时 0x00BC5F50 和 0x00BC5F5C 处还需要再存储一个值。

（3）virtual 已经能解决菱形继承所带来的问题了，为什么还是不建议使用？

在解决问题的同时，效率也降低了，它的这个对象模型变的更加复杂。之前是编译器编译完直接就可以找到，因为它们是紧挨着的，而现在却必须得通过指针来找到偏移量，再与现在的地址进行相加才可以找到。

下面是上面的 Person 关系菱形虚拟继承的原理解释：

八、继承的总结和反思

很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

多继承可以认为是 C++ 的缺陷之一，很多后来的 OO 语言都没有多继承，如 Java。

继承和组合

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

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

优先使用对象组合，而不是类继承。

可参考下面这篇博客：

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

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为 黑箱复用 （black-box reuse），因为对象的内部细节是不可见的。对象只以 “黑箱” 的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有

些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

// Car和BMW Car和Benz构成is-a的关系
class Car{
protected:
    string _colour = "白色"; // 颜色
    string _num = "粤DK0896"; // 车牌号
};
   
class BMW : public Car{
public:
    void Drive()
    {
        cout << "好开-操控" << endl;
    }
};
   
class Benz : public Car{
public:
    void Drive()
    {
        cout << "好坐-舒适" << endl;
    }
};
   
// Tire和Car构成has-a的关系
class Tire{
protected:
    string _brand = "Michelin"; // 品牌
    size_t _size = 17;          // 尺寸
};
   
class Car{
protected:
    string _colour = "白色";  // 颜色
    string _num = "粤DK0896"; // 车牌号
    Tire _t; // 轮胎
};

【C++】继承 -- 详解（下）

五、继承与友元

六、继承与静态成员

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

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

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

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

为什么 D 中 B 和 C 部分要去找属于自己的 A ？那么看看当下面的赋值发生时，d 是不是要去找出 B/C 成员中的 A 才能赋值过去？

（1）为什么需要偏移量？

（2）为什么不在 0x005EF75C、0x005EF764 直接存偏移量？

（3）virtual 已经能解决菱形继承所带来的问题了，为什么还是不建议使用？

八、继承的总结和反思

热门文章

最新文章

相关课程

相关电子书

相关实验场景