C++ 继承机制详解：实现栈、同名隐藏与派生类默认成员函数

#include <vector>
using namespace std;

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

通过宏替换容器类型（如 vector, list, deque）可以灵活实现不同底层的栈，预处理后宏会被替换为具体类型，不会存在残留的 CONTAINER。

对象赋值与切片

在公有继承条件下：

1. 子类转父类：可以将子类对象的一部分'切割'出来赋值给父类对象，或者赋值给父类指针/引用。这被称为对象切片。
2. 父类转子类：父类对象不能直接赋值给子类对象。
3. 强制转换：父类指针指向子类对象时，可以通过强制类型转换安全地转为子类指针。

作用域与同名隐藏

当子类和父类中存在同名成员时，子类成员会屏蔽父类对同名成员的直接访问，这种现象称为隐藏。

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

class Student : public Person {
public:
    void Print() {
        cout << _num << endl; // 打印 999
        // cout << Person::_num << endl; // 若要访问父类需指定作用域
    }
protected:
    int _num = 999;
};

重载 vs 隐藏

• 函数重载：要求在同一作用域内，函数名相同但参数列表不同。
• 函数隐藏：在不同作用域（如基类与派生类）中，只要函数名相同即构成隐藏，无论参数是否相同。

常见陷阱示例：

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(int)，正常
    b.fun();        // 报错！A::fun 被隐藏
    b.A::fun();     // 正确调用基类版本
    return 0;
}

尽量避免定义同名成员，若必须定义，请明确指定作用域。

派生类的默认成员函数

派生类会自动生成四个默认成员函数，但它们的行为与基类密切相关。

1. 构造函数

子类构造函数必须初始化基类部分。如果基类没有默认构造函数，则必须在初始化列表中显式调用。

// 基类无默认构造函数的情况
Student(const char* name, int num) : Person(name), _num(num) {}

初始化顺序：先初始化基类成员，再初始化派生类成员。对象构造时，先调用基类构造函数，后调用派生类构造函数。

2. 拷贝构造函数

对于内置类型进行值拷贝，对于自定义类型调用其拷贝构造。基类部分同样调用基类的拷贝构造。

Student(const Student& s) : Person(s), _num(s._num) {}

3. 赋值运算符重载

子类的 operator= 会隐藏基类的 operator=。如果需要处理基类数据，必须显式调用基类作用域。

Student& operator=(const Student& s) {
    if (this != &s) {
        Person::operator=(s); // 显式调用基类赋值
        _num = s._num;
    }
    return *this;
}

4. 析构函数

子类析构函数不需要显式调用基类析构函数。系统规定：析构顺序是先派生类后基类。这样能保证子类成员先清理，基类成员后清理，符合资源释放逻辑。

核心要点总结

1. 私有成员继承：私有成员确实被继承了（占用内存），但在子类中不可见，属于权限问题。
2. 对象大小：子类对象不一定比父类大，若仅重写方法而未增加新成员，大小可能一致。
3. 重载与隐藏：重载在同域，隐藏跨域。同名函数在派生类中会隐藏基类同名函数。
4. 构造顺序：先基类后派生类。若基类无默认构造，子类必须显式调用。
5. 析构顺序：先派生类后基类，无需手动调用基类析构。

理解这些机制有助于编写更安全、高效的 C++ 继承体系代码。