C++ 继承：同名成员隐藏与重载规则详解

二、继承的定义

定义的格式

在 C++ 中，基类也称为父类，派生类也称为子类。继承方式决定了基类成员在派生类中的访问权限。

继承方式主要有三种：public、protected、private。规则可以简化为：public > protected > private，选其中小一点的作为最终访问权限。

需要注意几个细节：

1. 使用关键字 class 时，默认的继承方式是 private；使用 struct 时，默认是 public。建议显式写出继承方式。
2. 实际开发中一般使用 public 继承，很少使用 protected 或 private 继承，因为后者会限制派生类外部对成员的访问，维护性较差。

继承类模板

继承不仅可以针对普通类，也可以针对类模板。例如，我们可以用继承实现一个基于 std::vector 的栈结构。

namespace say_fall {
    template<class T>
    class stack : public std::vector<T> {
    public:
        void push(const T& x) {
            // 基类是类模板时，需要指定一下类域，否则编译报错
            // 因为 stack<int> 实例化时，也实例化 vector<int> 了
            // 但是模版是按需实例化，push_back 等成员函数未实例化，所以找不到
            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（Run-Time Type Information）的 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. 在继承体系中，基类和派生类有独立的作用域。
2. 如果派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。
3. 对于成员函数，只要函数名相同就构成隐藏，无论参数是否不同。
4. 在实际开发中，继承体系里最好避免定义同名的成员，以免混淆。

// Student 的 _num 和 Person 的 _num 构成隐藏关系，这样代码虽然能跑，但是非常容易混淆
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();   // 编译错误
    return 0;
}

1. A 和 B 类中的两个 func 构成什么关系？
   • 答案：隐藏。回顾重载定义，其要求是一个作用域中的同名函数。继承出来的子类和父类实际上是在两个作用域的，所以是隐藏。
2. 上面程序的编译运行结果是什么？
   • 答案：编译报错。调用的 fun() 构成隐藏，在调用 b.fun(); 时，却没有传入参数，且 B 类中没有无参的 fun，因此编译器找不到匹配函数。

五、派生类默认成员函数

手动写类时，我们知道即使不实现，编译器也会生成默认成员函数。在继承的类中，这些函数会自动生成吗？规则又是什么样？

常见的四个默认成员函数包括：构造函数、析构函数、赋值运算符重载、拷贝构造函数。

1. 构造函数：派生类的构造函数必须调用基类的构造函数初始化基类那一部分成员。如果基类没有默认构造函数，则必须在派生类构造函数的初始化列表中显式调用。
2. 拷贝构造函数：派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 赋值运算符重载：派生类的 operator= 必须要调用基类的 operator= 完成基类的复制。需要注意的是，派生类的 operator= 隐藏了基类的 operator=，所以显式调用基类的 operator= 需要指定基类作用域。
4. 析构函数：派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

执行顺序总结：

• 初始化：先调用基类构造，再调用派生类构造。
• 析构：先调用派生类析构，再调用基类析构。

关于析构函数，在多态场景中，为了支持动态绑定，通常需要将基类析构函数声明为 virtual。如果不加 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);
            // operator=(s); 会触发递归，因为调用的是自己的 operator=()
            _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;
}

掌握这些规则，能有效避免继承体系中的常见陷阱。