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

访问权限与继承方式

1. 私有成员的可见性：父类的 private 成员在子类中无论以何种方式继承都是不可见的。这并不意味着它们没有被继承，而是子类对象无法直接访问它们。例如，上述代码中 _age 是私有的，在 Student 中直接访问会报错。
2. 保护成员的作用：如果希望某些成员不在类外直接访问，但允许子类访问，应定义为 protected。这是为继承而生的访问限定符。
3. 总结：父类的私有成员在子类中不可见。其他成员的访问权限取决于 Min(成员在父类的访问限定符，继承方式)。顺序为 public > protected > private。
4. 实践建议：通常使用 public 继承。class 默认继承方式为 private，struct 默认为 public。

基于继承实现栈（模板特例）

利用容器适配器模式，我们可以通过继承 std::vector 来实现一个栈。这里涉及模板的按需实例化和依赖名称查找的问题。

如果在 push 成员函数中不指定类域，编译器可能无法正确解析父类模板成员。因为 vector<T> 是依赖类型，编译器需要明确知道 push_back 来自父类。

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

通过宏定义可以灵活切换底层容器（如 list 或 deque），预处理后宏会被替换，不会存在未定义的标识符问题。

对象赋值与切片

1. 子类转父类：在公有继承下，可以将子类对象的一部分'切割'出来赋值给父类对象，或者赋值给父类的指针/引用。这被称为对象切片（Slicing）。
2. 父类转子类：父类对象不能直接赋值给子类对象。
3. 强制转换：父类指针可以通过强制类型转换指向子类对象，但这要求该指针实际指向的是子类对象实例，否则不安全。

作用域与同名隐藏

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

#include <iostream>
#include <string>
using namespace std;

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

class Student : public Person {
public:
    void Print() {
        cout << _num << endl; // 输出 999，屏蔽了父类的 111
        // cout << Person::_num << endl; // 若要访问父类成员需指定作用域
    }
protected:
    int _num = 999;
};

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

函数重载 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)，输出 func(int i)10
    b.fun();     // 编译错误！A::fun() 被 B::fun(int) 隐藏
    b.A::fun();  // 正确，显式调用基类版本
    return 0;
}

派生类的默认成员函数

派生类会自动生成四个默认成员函数，但它们的行为受基类影响。

1. 构造函数

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

• 内置类型：默认构造函数不初始化，值不确定。
• 自定义类型：调用其默认构造函数。
• 继承成员：视为整体，调用基类默认构造函数。

// 初始化列表顺序：先基类，再子类成员
Student(const char* name, int num, const char* address)
    : Person(name), _num(num), _address(address) {}

2. 拷贝构造

对于内置类型执行值拷贝，自定义类型调用拷贝构造，基类部分调用基类拷贝构造。

Student(const Student& s) : Person(s), _num(s._num) {
    cout << "Student(const Student& s)" << endl;
}

3. 赋值运算符

子类 operator= 会隐藏基类的 operator=。若需调用基类逻辑，必须指定作用域。

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

4. 析构函数

子类析构函数完成后会自动调用基类析构函数。这保证了清理顺序：先派生类，后基类。

~Student() {
    // ~Person(); // 不需要显式调用，系统自动处理
}

总结：构造、拷贝构造、赋值运算符通常需要显式调用基类对应函数（除非基类有默认且无需特殊处理），而析构函数由系统自动按逆序调用。理解这些机制对于编写安全的 C++ 继承体系至关重要。

核心知识点回顾：

1. 基类私有成员被继承但在子类中不可见。
2. 子类对象大小不一定大于父类，取决于是否增加新成员。
3. 函数重载在同一作用域，隐藏在不同作用域。
4. 构造函数初始化列表必须先初始化基类，再初始化子类成员。
5. 析构顺序与构造相反，先析构派生类，再析构基类。