C++ 继承中同名成员的隐藏与重载规则解析

二、继承的定义

定义的格式

在 C++ 中，基类也称为父类，派生类也称为子类。继承方式决定了基类成员在派生类中的访问权限。常见的继承方式有 public、protected 和 private。

• public 继承：基类的 public/protected 成员在派生类中保持原有访问权限。
• protected 继承：基类的 public 成员变为 protected，protected 成员保持 protected。
• private 继承：基类的所有成员在派生类中都变为 private。

使用 class 关键字时默认继承方式是 private，而 struct 默认为 public。实际开发中通常显式指定继承方式，且绝大多数场景使用 public 继承。

继承类模板

继承不仅可以用于普通类，还可以用于类模板。例如用继承实现一个 stack 容器，底层复用 vector 的功能。

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

template<class T>
class Stack : public 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() {
    Stack<int> st;
    st.push(1);
    st.push(2);
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    return 0;
}

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

继承关系类似于严格的父子关系，对象转换遵循特定规则：

1. 向上转换（Upcasting）：派生类对象可以赋值给基类的指针或引用。这是安全的，因为派生类包含基类部分。
2. 向下转换（Downcasting）：基类对象不能直接赋值给派生类对象。若必须转换，需确保基类指针实际指向的是派生类对象，建议使用 dynamic_cast 进行安全转换。

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

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

int main() {
    Student sobj;
    // 派生类对象可以赋值给基类的指针/引用
    Person* pp = &sobj;
    Person& rp = sobj;
    
    // 基类对象不能赋值给派生类对象，会编译报错
    // sobj = pobj; 
    return 0;
}

四、继承的作用域

隐藏规则与重载比较

在继承体系中，基类和派生类拥有独立的作用域。当两者出现同名成员时，派生类成员将屏蔽基类对同名成员的直接访问，这种现象称为隐藏。

• 重载：要求在同一作用域下，函数名相同但参数不同。
• 隐藏：只要函数名相同，无论参数是否匹配，都会构成隐藏。

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

相关示例分析

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() 被隐藏
    return 0;
}

由于继承体系中存在两个作用域，B 类中的 fun(int) 隐藏了 A 类中的 fun()。因此调用无参版本时会报错，除非显式使用 b.A::fun()。

五、派生类默认成员函数

派生类会自动生成默认成员函数，但其行为受基类影响。常见的四个默认成员函数包括构造函数、析构函数、拷贝构造函数和赋值运算符重载。

1. 构造函数：派生类构造函数必须调用基类构造函数初始化基类部分。若基类无默认构造函数，必须在初始化列表中显式调用。
2. 拷贝构造函数：同样需要调用基类的拷贝构造函数。
3. 赋值运算符：派生类的 operator= 会隐藏基类的 operator=。若需执行基类逻辑，需显式指定作用域调用 Person::operator=(s)。
4. 析构函数：派生类析构函数调用完成后，会自动调用基类析构函数。顺序是先清理派生类成员，再清理基类成员。

注意：在多态场景中，基类析构函数建议声明为 virtual，否则派生类析构函数可能与基类构成隐藏而非重写，导致资源泄漏。

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

掌握这些规则有助于编写更安全、可维护的 C++ 继承代码。