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

1.2.2 访问权限变化规则

继承方式会改变基类成员在派生类中的访问权限。具体规则如下：

1. 基类 private 成员：无论以何种方式继承，在派生类中均不可见（虽然物理上存在，但语法限制无法直接访问）。若需访问，可通过基类的公有接口。
2. 基类 protected 成员：在派生类内部可见，外部不可见。
3. 基类 public 成员：根据继承方式不同，可能保持 public 或变为 protected/private。

注意：基类其他成员在派生类中的访问方式 == Min(成员在基类的访问限定符，继承方式)。即 public > protected > private。

在实际运用中，一般使用 public 继承。protected 或 private 继承下来的成员通常只能在派生类内部使用，维护性较差，不提倡滥用。

1.2.3 模板继承

继承类模板时，如果基类是类模板，实例化时需要指定类域，否则编译可能报错。

namespace wzy {
    template<class T>
    class stack : public std::vector<T> {
    public:
        void push(const T& x) {
            // 必须指定 vector<T>::push_back(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() {
    wzy::stack<int> st;
    st.push(1);
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    return 0;
}

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

2.1 不同的转换方式

2.1.1 会产生临时变量

不同类型变量之间的转换（如 int 转 double）会产生临时对象。由于临时对象具有常性，引用绑定通常需要加 const。

int main() {
    double d = 1.2;
    const int& i = d; // 正确，绑定临时变量需要 const
    // int& i = d; // 错误，非 const 引用不能绑定临时对象
    return 0;
}

2.1.2 不会产生临时变量（赋值兼容规则）

在公有继承的前提下，派生类对象可以赋值给基类的指针或引用，中间不产生临时变量。这被称为'对象切片'或'切割'，即只保留派生类中属于基类的那部分数据。

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

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

int main() {
    Student sobj;
    // 派生类对象赋值给基类指针/引用，无临时变量
    Person* pp = &sobj;
    Person& rp = sobj;
    // 派生类对象赋值给基类对象，调用拷贝构造，会有切片
    Person pobj = sobj;
    return 0;
}

规则总结：

1. 公有继承的派生类对象可赋值给基类指针/引用。
2. 基类对象不能赋值给派生类对象。
3. 基类指针/引用可通过强制类型转换赋值给派生类指针/引用，但需确保指向的是派生类对象（多态下可用 dynamic_cast 安全转换）。

三、继承中的作用域

继承体系中，基类和派生类有独立的作用域。同名成员会导致隐藏。

3.1 隐藏规则

1. 派生类成员屏蔽基类同名成员的直接访问。
2. 成员函数隐藏只需函数名相同（与重载不同，重载要求同一作用域且参数不同）。
3. 访问被隐藏的基类成员需指定命名空间，如 Base::member。

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

class Student : public Person {
public:
    void Print() {
        cout << "姓名:" << _name << endl; // 访问派生类隐藏后的_name
        cout << "身份证号:" << Person::_num << endl; // 指定作用域访问基类_num
        cout << "学号:" << _num << endl;
    }
protected:
    int _num = 999;
};

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();   // 编译报错，基类 fun() 被隐藏
    return 0;
}

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

派生类构造函数必须调用基类构造函数初始化基类部分。析构顺序则是先析构派生类，再析构基类。

常见规则：

1. 派生类构造函数必须显式或隐式调用基类构造函数。
2. 派生类拷贝构造函数需调用基类拷贝构造函数。
3. 派生类赋值运算符需调用基类赋值运算符（注意作用域隐藏）。
4. 派生类析构函数自动调用基类析构函数。

class Person {
public:
    Person(const char* name = "peter") : _name(name) { cout << "Person()" << endl; }
    ~Person() { cout << "~Person()" << endl; }
protected:
    string _name;
};

class Student : public Person {
public:
    // 手动写构造函数需调用基类
    Student(const char* name, const char* address, int num)
        : Person(name), _address(address), _num(num) {}

    // 赋值重载需指定基类作用域
    Student& operator=(const Student& s) {
        if (this != &s) {
            Person::operator=(s); // 显式调用基类
            _address = s._address;
            _num = s._num;
        }
        return *this;
    }
    ~Student() { /* 编译器自动调用基类析构 */ }
protected:
    string _address;
    int _num;
};

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

C++11 引入了 final 关键字，修饰基类后禁止继承。旧版本可通过私有化构造函数实现，但不推荐。

class Base final {
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
};
// class Child : public Base {}; // 编译报错

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

6.1 继承与友元

友元关系不能继承。基类的友元无法访问派生类的私有或保护成员。

6.2 继承与静态成员

静态成员在整个继承体系中只有一个实例，不会随派生类生成副本。

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;
    cout << &p._name << endl; // 地址不同，普通成员有副本
    cout << &p._count << endl; // 地址相同，静态成员共享
    return 0;
}

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

7.1 多继承与菱形继承

多继承指一个派生类有多个直接基类。菱形继承是多继承的特殊情况，会导致数据冗余和二义性。

7.2 继承模型

单继承结构简单。多继承内存布局通常是先继承的基类在前，后继承的在后，派生类成员在最后。

7.3 菱形继承问题及解决

菱形继承中，最底层的类会包含两份基类成员，导致二义性和冗余。

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

使用 virtual 关键字进行虚拟继承，可确保基类成员在内存中唯一。

7.4 多继承指针偏移

多继承下，不同基类指针的地址可能与派生类对象地址不一致，存在偏移量。

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; // 偏移 0
    Base2* p2 = &d; // 偏移 sizeof(Base1)
    Derive* p3 = &d; // 偏移 0
    return 0;
}

八、继承和组合

• 继承是 is-a 关系，破坏封装，耦合度高。
• 组合是 has-a 关系，黑箱复用，耦合度低。

优先使用组合而非继承。只有当确实是 is-a 关系或需要实现多态时才考虑继承。

class Tire { protected: string _brand; };
class Car {
protected:
    Tire _t1, _t2, _t3, _t4; // 组合
};
class BMW : public Car { }; // 继承

掌握这些机制有助于构建高可维护性的面向对象系统。