C++ 继承机制详解

模板继承示例

通过继承类模板可以实现更灵活的容器封装，例如用 vector 实现栈。

namespace example {
    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() {
    example::stack<int> st;
    st.push(1);
    st.push(2);
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    return 0;
}

基类和派生类间的转换

2.1 类型转换与临时变量

不同类型间转换（如 int 转 double）会产生临时对象。但在基类和派生类之间，情况有所不同。

2.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. 向上转型：public 继承的派生类对象可赋值给基类指针/引用（天然支持）。
2. 向下转型：基类对象不能直接赋值给派生类对象。基类指针/引用可通过强制转换指向派生类对象，但需确保实际指向的是派生类对象（多态场景下建议使用 dynamic_cast）。

继承中的作用域

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

3.1 隐藏规则

1. 变量隐藏：派生类成员屏蔽基类同名成员的直接访问。需通过作用域解析运算符 Base::member 显式访问。
2. 函数隐藏：只要函数名相同即构成隐藏，无需参数不同（这与重载不同，重载要求同一作用域且参数不同）。

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

class Student : public Person {
public:
    void Print() {
        cout << "姓名:" << _name << endl; // 访问派生类成员
        cout << "身份证号:" << Person::_num << endl; // 显式访问基类成员
    }
protected:
    int _num = 999; // 隐藏了基类的 _num
};

3.2 函数隐藏 vs 重载

基类和派生类之间的同名函数构成隐藏关系，而非重载。

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::fun(int)
    b.A::fun();    // 必须显式指定才能调用 A::fun()
}

派生类的默认成员函数

派生类对象的生命周期涉及基类部分的初始化和清理。

核心规则：

1. 构造顺序：先调用基类构造函数，再调用派生类构造函数。
2. 析构顺序：先调用派生类析构函数，再调用基类析构函数。
3. 拷贝构造与赋值：派生类需显式调用基类的对应函数。注意赋值运算符重载会隐藏基类的版本，需通过 Base::operator= 调用。
4. 虚析构：若涉及多态，基类析构函数应声明为 virtual，否则派生类析构函数会与基类形成隐藏，导致资源泄漏。

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) : Person(name) {} // 显式调用基类构造
    Student& operator=(const Student& s) {
        if (this != &s) {
            Person::operator=(s); // 显式调用基类赋值
            // ... 处理派生类成员
        }
        return *this;
    }
    ~Student() { /* 编译器自动调用基类析构 */ }
};

实现不能被继承的类

有两种常见方法：

1. C++98：将基类构造函数设为 private，派生类无法调用。
2. C++11：使用 final 关键字修饰类。

class Base final {
public:
    void func() { cout << "Base::func" << endl; }
};
// class Child : public Base {}; // 编译错误

继承与友元、静态成员

6.1 友元关系

友元关系不能继承。基类的友元无法访问派生类的私有或保护成员。若需访问，需在派生类中重新声明友元。

6.2 静态成员

静态成员属于整个继承体系，所有类共享同一份实例，不会因继承产生副本。

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

class Student : public Person {
    // ...
};

int main() {
    Person p; Student s;
    cout << &p._count << endl; // 地址相同
    cout << &s._count << endl; // 地址相同
    return 0;
}

多继承、菱形继承与虚继承

7.1 继承模型

• 单继承：一个派生类只有一个直接基类。
• 多继承：一个派生类有多个直接基类。内存布局通常是基类依次排列，派生类成员在最后。
• 菱形继承：多继承的特殊情况，导致数据冗余和二义性。

7.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 {
    // 此时 Assistant 中有两份 Person 的成员
};

7.3 解决方案

1. 指定作用域：解决二义性，但无法解决数据冗余。
2. 虚拟继承：使用 virtual 关键字，确保基类在内存中只存在一份。

class Student : virtual public Person { ... };
class Teacher : virtual public Person { ... };
// Assistant 中 Person 成员唯一

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; // 地址偏移
    Base2* p2 = &d; // 地址偏移更大
    Derive* p3 = &d; // 原始地址
    // p1 != p2 != p3
}

继承与组合

• 继承（is-a）：派生类对象是基类对象的一种。破坏封装，耦合度高。
• 组合（has-a）：对象中包含另一个对象。黑箱复用，耦合度低。

原则：优先使用组合，除非明确需要 is-a 关系或多态需求。

class Tire { ... };
class Car {
    Tire _t1, _t2, _t3, _t4; // 组合
};

class BMW : public Car { ... }; // 继承

多继承虽强大，但底层复杂且易引发菱形问题，实际设计中应谨慎使用。