C++ 继承机制详解：同名成员调用与隐藏规则

二、继承的定义与方式

Person 是基类（父类），Student 和 Teacher 是派生类（子类）。继承方式决定了基类成员在派生类中的访问权限。

继承方式主要有三种：public、protected、private。规则可以简单理解为权限的缩小：public > protected > private。选择其中较小的权限作为最终访问级别。

1. 默认继承方式：使用关键字 class 时默认为 private 继承；使用 struct 时默认为 public 继承。实际开发中建议显式写出继承方式。
2. 常用场景：实际运用中一般使用 public 继承。protected/private 继承下来的成员只能在派生类内部使用，扩展性和维护性较弱，不提倡过度使用。

此外，继承不仅可以针对普通类，还可以针对类模板。

继承类模板示例

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

这里用继承实现了 stack 类，而不是之前适配器常用的组合方法。注意当基类是类模板时，实例化时需要指定作用域，因为模版是按需实例化的，未使用的成员函数可能未被实例化。

三、基类和派生类之间的转换

继承关系类似于严格的父子财产关系，转换需遵循以下规则：

1. 向上转换（Upcasting）：public 继承的派生类对象可以赋值给基类的指针或引用。这被称为'切片'或'切割'，即派生类中基类那部分被切出来，基类指针指向这部分内容。
2. 向下转换（Downcasting）：基类对象不能直接赋值给派生类对象。基类指针可以通过强制类型转换赋值给派生类指针，但必须确保基类指针实际指向的是派生类对象，否则不安全。若基类是多态类型，可使用 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;
}

四、继承的作用域与隐藏规则

1. 重载与隐藏的区别

• 重载：在同一作用域下的同名函数，参数不同构成重载。
• 隐藏：在继承体系中，基类和派生类有独立的作用域。派生类成员将屏蔽基类对同名成员的直接访问。

如果是成员函数的隐藏，只要函数名相同就构成隐藏，无需参数不同。在实际项目中，继承体系内最好避免定义同名成员，以免混淆。

class Person {
protected:
    string _name = "小李子";
    int _num = 111; // 身份证号
};

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

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

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

A 和 B 类中的两个 fun 构成什么关系？答案是隐藏。因为它们在两个不同的作用域中，不符合重载定义。调用 b.fun() 时没有传入参数，而 B 类中只有带参数的版本，导致编译错误。

五、派生类默认成员函数

即使不手动实现，编译器也会生成默认成员函数。但在继承体系中，这些函数的生成和调用规则更为复杂。

1. 构造函数：派生类构造函数必须调用基类构造函数初始化基类部分。如果基类没有默认构造函数，必须在初始化列表中显式调用。
2. 拷贝构造：派生类拷贝构造需调用基类拷贝构造完成基类部分的复制。
3. 赋值运算符：派生类的 operator= 会隐藏基类的 operator=。如需调用基类版本，需指定作用域 Base::operator=。
4. 析构函数：派生类析构函数完成后会自动调用基类析构函数。顺序是先清理派生类成员，再清理基类成员。

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:
    Student(const char* name, int num) : Person(name), _num(num) {
        cout << "Student()" << endl;
    }
    Student(const Student& s) : Person(s), _num(s._num) {
        cout << "Student(const Student& s)" << endl;
    }
    Student& operator=(const Student& s) {
        cout << "Student& operator= (const Student& s)" << endl;
        if (this != &s) {
            // 构成隐藏，需要显式调用基类版本
            Person::operator=(s);
            _num = s._num;
        }
        return *this;
    }
    ~Student() {
        cout << "~Student()" << endl;
    }
protected:
    int _num;
};

int main() {
    Student s1("jack", 18);
    Student s2(s1);
    Student s3("rose", 17);
    s1 = s3;
    return 0;
}

注意析构函数在多态场景下通常需要设为 virtual，否则派生类析构函数会与基类构成隐藏而非重写，可能导致资源泄漏。