C++ 继承机制详解：从基础概念到多继承模型

1.2.2 成员访问方式的变化

继承基类的方式不同，会导致访问基类成员的方式不同。具体规则如下：

核心规则：

1. 基类 private 成员在派生类中无论以什么方式继承都是不可见的。 这里的'不可见'是指语法上限制派生类对象不能访问它（即使内存中存在）。如果需要在派生类中访问，可以在基类中设计一个公有函数。
2. 基类 protected 成员是因继承才出现的限定符。如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为 protected。
3. 访问权限计算： 基类的其他成员在派生类的访问方式 == Min(成员在基类的访问限定符，继承方式)。即 public > protected > private。
4. 默认继承方式： 使用关键字 class 时默认的继承方式是 private，使用 struct 时默认的继承方式是 public。不过最好显式地写出继承方式。

注意：在实际运用中一般使用 public 继承，几乎很少使用 protected/private 继承，因为后者继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

示例：

class Person {
public:
    void identity() { /* ... */ }
    // 为了满足基类中的私有成员可以在派生类中可见，在基类中设计一个公有函数进行访问
    void func() { ++_age; }
protected:
    string _name = "peter";
    string _address;
    string _tel;
private:
    int _age = 18;
};

class Student : public Person {
public:
    void study() {
        _name = "张三"; // 可以访问 protected 成员
        // _age++; // 错误：基类中的 (private) 私有成员，不管与哪种方式继承，都是在派生类中不可见
    }
protected:
    int _stuid;
};

int main() {
    Student s;
    s.identity(); // 基类中的公有成员，通过 public 继承是派生类中的公有成员
    s.func();     // 对基类中的私有成员进行访问
    return 0;
}

1.2.3 继承类模板

这里通过继承类模板来实现栈功能，而不是组合。

namespace utils {
    template<class T>
    class stack : public std::vector<T> {
    public:
        void push(const T& x) {
            // 基类是类模板时，需要指定一下类域，否则编译报错
            vector<T>::push_back(x);
        }
        void pop() {
            vector<T>::pop_back();
        }
        const T& top() {
            return vector<T>::back();
        }
        bool empty() {
            return vector<T>::empty();
        }
    };
}

int main() {
    utils::stack<int> st;
    st.push(1);
    st.push(2);
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    return 0;
}

二、基类和派生类间的转换

2.1 不同的转换方式

2.1.1 会产生临时变量

不同类型变量之间支持类型转换，并且之间会产生临时对象。例如 int 和 double 之间的转换。

int main() {
    double d = 1.2;
    // int& i = d; // error: 赋值转化时，首先会将变量 d 转化为 int 类型并将结果存在一个临时变量里
    // 引用绑定的对象实际是这个临时变量，所以必须加 const
    const int& i = d;
    return 0;
}

2.1.2 不会产生临时变量（基类和派生类间的转换）

在基类和派生类对象之间的赋值转换并不会产生临时变量。派生类赋值给基类对象的指针或者引用，我们认为这是天然的，中间不产生临时变量，这个叫做赋值兼容规则（或切割、切片）。

验证：

class Person {
protected:
    string _name;
    string _sex;
    int _age;
};

class Student : public Person {
public:
    int _No;
};

int main() {
    Student sobj;
    // 派生类对象可以赋值给基类的指针/引用，并且中间不会产生临时变量
    Person* pp = &sobj;
    Person& rp = sobj;
    return 0;
}

运行这段代码发现可以正常通过，也从侧面说明基类和派生类对象之间的赋值转换不会产生临时变量。将派生类对象赋值给基类的指针/引用，从而可以得到派生类中基类那部分叫切片或者切割（但要注意这建立在公有 public 继承的方式条件下）。

规则：

• public 继承的派生类对象可以赋值给基类的指针/引用。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。
• 基类对象不能赋值给派生类对象。
• 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。如果基类是多态类型，可以使用 RTTI (dynamic_cast) 来进行识别后进行安全转换。

class Person {
protected:
    string _name;
    string _sex;
    int _age;
};

class Student : public Person {
public:
    int _No;
};

int main() {
    Student sobj;
    // 1. 派生类对象可以赋值给基类的指针/引用
    Person* pp = &sobj;
    Person& rp = sobj;
    // 派生类对象可以赋值给基类的对象是通过调用基类的拷贝构造完成的
    Person pobj = sobj;
    
    // 2. 基类对象不能赋值给派生类对象，这里会编译报错
    // sobj = pobj;
    return 0;
}

三、继承中的作用域

继承中的作用域主要注意基类和派生类的成员变量中间可能会产生隐藏。

3.1 隐藏规则

1. 在继承体系中基类和派生类都有独立的作用域。
2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用 基类::基类成员 显式访问）
3. 如果是成员函数的隐藏，只需要函数名相同就构成隐藏。注意和函数重载进行区分，函数重载要建立在同一作用域的前提下，而基类和派生类形成成员函数隐藏是在不同作用域中。

注意：在实际中在继承体系里面最好不要定义同名的成员。

示例：

class Person {
protected:
    string _name = "wdefg";
    int _num = 111;
};

class Student : public Person {
public:
    void Print() {
        cout << "姓名:" << _name << endl;
        // 要想访问基类中的_num 成员变量，由于和派生类中的变量_num 形成隐藏，所以要指定命名空间访问
        cout << "身份证号:" << Person::_num << endl;
        cout << "学号:" << _num << endl;
    }
protected:
    int _num = 999;
};

int main() {
    Student s1;
    s1.Print();
    return 0;
}

成员函数隐藏示例：

class A {
public:
    void fun() { cout << "func()" << endl; }
};

class B : public A {
public:
    void fun(int i) { cout << "func(int i)" << endl; }
};

int main() {
    B b;
    b.fun(1);       // 访问派生类中的成员函数
    b.A::fun();     // 访问基类中的成员函数
}

3.2 考察继承作用域相关选择题

class A {
public:
    void fun() { cout << "func()" << endl; }
};

class B : public A {
public:
    void fun(int i) { cout << "func(int i)" << i << endl; }
};

int main() {
    B b;
    b.fun(10);
    b.fun(); // 编译报错
    return 0;
}

问题解析：

1. A 和 B 类中的两个 func 构成什么关系？答案是 B. 隐藏。函数重载要建立在同一作用域的前提下，不在同一作用域没有函数重载之说。
2. 程序的编译运行结果是什么？答案是 A. 编译报错。由于基类和派生类中的成员函数 fun 形成了隐藏，所以要访问基类中的成员函数要指定空间，而这里没有指定。

四、派生类的默认成员函数

6 个默认成员函数，默认的意思就是指我们不写，编译器会自动生成一个。那么在派生类中，常见的 4 个成员函数【默认构造、拷贝构造、赋值重载、析构函数】是如何生成的呢？

常见默认成员函数规则：

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

总结：

1. 记住前面默认成员函数的规则。
2. 把基类成员当成一个整体规则和以前的自定义类型规则一样。

示例：

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:
    // 1. 默认构造
    // 如果基类中有默认构造函数，和以前的自定义类型一样，就会自动调用对应的默认构造函数
    // 那如果要自己手动写，此时就要调用基类中的默认构造函数
    Student(const char* name, const char* address, int num)
        : Person(name), _address(address), _num(num) {}

    // 2. 拷贝构造
    // 如果基类中有拷贝构造函数，和以前的自定义类型一样，就会自动调用对应的构造函数
    // 显示调用基类的拷贝构造函数，可以通过切片进行传参
    Student(const Student& s)
        : Person(s), _address(s._address), _num(s._num) {}

    // 3. 赋值重载
    // 由于基类和派生类中的赋值重载函数和基类中的赋值重载函数形成隐藏，所以显式调用基类的 operator=，需要指定基类作用域
    Student& operator=(const Student& s) {
        if (this != &s) {
            Person::operator=(s); // 显式调用基类的 operator=
            _address = s._address;
            _num = s._num;
        }
        return *this;
    }

    // 4. 析构函数
    ~Student() {
        // 这里不显示调用基类的析构函数，由于编译器会在结束后在后面自动 call 基类的析构函数
        // 如果此时我们还显示调用就调用了两次就会出问题
    }
protected:
    string _address = "李四";
    int _num = 1;
};

五、实现一个不能被继承的类

5.1 方法（两种）

1. 方法 1： 基类的构造函数私有，派生类的构造必须调用基类的构造函数，但是基类的构造函数私有化以后，派生类看不见就不能调用了，那么派生类就无法实例化出对象。
2. 方法 2： C++11 新增了一个 final 关键字，final 修改基类，派生类就不能继承了。（现在一般用这种）

示例：

// C++11 的方法
class Base final {
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
private:
    // C++98 的方法
    // Base() {}
};

六、继承与友元、继承与静态成员

6.1 继承与友元

友元关系不能继承（由于相互依赖关系导致），也就是说基类友元不能访问派生类私有和保护成员。

示例：

class Student;
class Person {
public:
    friend void Display(const Person& p, const Student& s);
protected:
    string _name;
};

// 友元关系不能继承
class Student : public Person {
    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; // 编译报错：无法访问 protected 成员
}

int main() {
    Person p;
    Student s;
    Display(p, s);
    return 0;
}

6.2 继承与静态成员

基类定义了 static 静态成员，则整个继承体系里只有一个这样的成员（由于其作用域导致，静态成员变量作用域是静态区）。无论派生出多少个派生类，都只有一个 static 成员实例（也就是不会生成副本，想普通成员不仅会继承还会生成副本）。

示例：

class Person {
public:
    string _name;
    static int _count;
};
int Person::_count = 0;

class Student : public Person {
protected:
    int _stuNum;
};

int main() {
    Person p;
    Student s;
    // 非静态成员_name 的地址是不一样的，说明派生类继承下来了，父派生类对象各有一份
    cout << &p._name << endl;
    cout << &s._name << endl;
    
    // 静态成员_count 的地址是一样的，说明派生类和基类共用同一份静态成员
    cout << &p._count << endl;
    cout << &s._count << endl;
    
    Student s1; Person p1;
    cout << "人数 :" << Person::_count << endl;
    Student s2; Student s3;
    cout << "人数 :" << Person::_count << endl;
    return 0;
}

七、多继承、菱形继承、虚继承

7.1 多继承、菱形继承、虚继承的关系

继承分为单继承和多继承。而菱形继承是多继承的一种特殊情况，虚拟继承则是为了解决其中的一些问题孕育而生。

7.2 继承模型

7.2.1 单继承

一个派生类只有一个直接基类时称这个继承关系为单继承。

7.2.2 多继承

一个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后面继承的基类在后面，派生类成员放到最后面。

7.2.3 菱形继承

菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，在 Assistant 的对象中 Person 成员会有两份。支持多继承就一定会有菱形继承，像 Java 就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型的。

7.3 菱形继承问题（数据冗余和二义性）的解决办法

示例：

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 二义性解决办法（1）—— 指定类域显示访问

虽然显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决。

a.Student::_name = "wzy";
a.Teacher::_name = "wzz";

7.3.2 二义性解决办法（2）—— 虚拟继承

在上面的继承关系中，在 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";
}

7.4 多继承中指针偏移问题

下面说法正确的是（ ）

A：p1 == p2 == p3 B：p1 < p2 < p3 C：p1 == p3 != p2 D：p1 != p2 != p3

class Base1 {
public:
    int _b1;
};
class Base2 {
public:
    int _b2;
};
class Derive : public Base1, public Base2 {
public:
    int _d;
};

int main() {
    Derive d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derive* p3 = &d;
    return 0;
}

7.5 总结

有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂，性能也会有一些损失，所以最好不要设计出菱形继承。多继承可以认为是 C++ 的缺陷之一。我们可以设计出多继承，但是不建议设计出菱形继承，因为菱形虚拟继承以后，无论是使用还是底层都会复杂很多。当然有多继承语法支持，就一定存在会设计出菱形继承，像 Java 是不支持多继承的，就避开了菱形继承。那是不是生活中就没人使用菱形继承呢？答案肯定是否定的就连 C++ 的库中也用了菱形继承。例如：IO 库中的菱形虚拟继承。

八、继承和组合

• public 继承是一种 is-a 的关系。 也就是说每个派生类对象都是一个基类对象。
• 组合是一种 has-a 的关系。 假设 B 组合了 A，每个 B 对象中都有一个 A 对象。
• 继承允许你根据基类的实现来定义派生类的实现。 这种通过生成派生类的复用通常被称为白箱复用 (white-box reuse)。术语'白箱'是相对可视性而言：在继承方式中，基类的内部细节对派生类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
• 对象组合是类继承之外的另一种复用选择。 新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用 (black-box reuse)，因为对象的内部细节是不可见的。对象只以'黑箱'的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
• 优先使用组合，而不是继承。 实际尽量多用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承 (is-a) 那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承 (is-a) 也适合组合 (has-a)，就用组合。

示例：

// Tire(轮胎) 和 Car(车) 更符合复用（has-a）的关系
class Tire {
protected:
    string _brand = "Michelin";
    size_t _size = 17;
};

class Car {
protected:
    string _colour = "白色";
    string _num = "陕 ABIT00";
    Tire _t1; // 轮胎
    Tire _t2; // 轮胎
    Tire _t3; // 轮胎
    Tire _t4; // 轮胎
};

class BMW : public Car {
public:
    void Drive() { cout << "好开 - 操控" << endl; }
};

// Car 和 BMW/Benz 更符合继承（is-a）的关系
class Benz : public Car {
public:
    void Drive() { cout << "好坐 - 舒适" << endl; }
};

template<class T> class vector {};
// stack 和 vector 的关系，既符合继承（is-a），也符合复用（has-a）
template<class T> class stack : public vector<T> {};
template<class T> class stack {
public:
    vector<T> _v;
};

int main() {
    return 0;
}