C++ 继承入门：从概念定义到默认成员函数详解

3. 继承方式与成员访问权限

父类成员在子类中的访问权限，取决于'父类的访问限定符'和'继承方式'。核心规则是：最终访问权限 = Min(父类成员权限，继承方式)。

• 基类 private 成员在派生类中无论以什么方式继承都是不可见的。虽然它们被继承到了对象内存中，但语法上限制无法访问。
• 如果基类成员不想在类外直接被访问，但需要在派生类中能访问，应定义为 protected。保护成员限定符是因继承才出现的。
• 使用关键字 class 时默认继承方式是 private，使用 struct 时默认是 public。实际开发中建议显式写出继承方式，且一般使用 public 继承。

实战示例：用继承实现 Stack

#include<iostream>
#include<vector>
#include<list>
#include<deque>
using namespace std;
#define CONTAINER vector

namespace MyStack {
    template<class T>
    class stack : public std::CONTAINER<T> {
    public:
        void push(const T& x) {
            // 基类是类模板时，需要指定类域，否则编译报错
            CONTAINER<T>::push_back(x);
        }
        void pop() { CONTAINER<T>::pop_back(); }
        const T& top() { return CONTAINER<T>::back(); }
        bool empty() { return CONTAINER<T>::empty(); }
    };
}

void Test2() {
    MyStack::stack<int> st;
    st.push(1); st.push(2); st.push(3);
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
}

int main() {
    Test2();
    return 0;
}

二、基类与派生类的转换

这是继承的核心特性之一：子类对象能隐式转换成父类对象 / 指针 / 引用，反之不行。

• 派生类对象 → 基类指针/引用：可以赋值，这叫'切片'或'切割'，即把派生类中基类那部分切出来。
• 基类对象 → 派生类对象：不能赋值，因为基类没有子类的成员，强行转换会导致越界。
• 强制转换：基类指针指向派生类对象时，可以通过 dynamic_cast 安全转换回派生类指针（需开启多态）。

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

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

void Test3() {
    Student st;
    // 1. 派生类对象 → 基类指针/引用（隐式转换，安全）
    Person* ppe = &st;      // 指向子类对象的'父类部分'
    Person& rpe = st;       // 引用子类对象的'父类部分'
    
    // 2. 派生类对象 → 基类对象（调用拷贝构造，只拷贝父类部分）
    Person pe = st;
    
    // 3. 基类对象 → 派生类对象（编译报错，不安全）
    // st = pe; 
}

三、继承中的作用域：同名成员会冲突吗？

父类和子类有独立的作用域。如果出现同名成员，子类会隐藏父类的同名成员，这就是'隐藏规则'。

• 派生类和基类有同名成员，派生类成员将屏蔽基类对同名成员的直接访问。
• 如果是成员函数的隐藏，只需要函数名相同就构成隐藏（参数列表不同也没用）。
• 避坑提醒：尽量不要定义同名成员。如果必须同名，访问时一定要加父类作用域。

1. 变量隐藏

class Person {
protected:
    string _name = "张三";
    int _num = 123456; // 身份证号
};

class Student : public Person {
public:
    void Print() {
        // 同名变量：默认访问子类的_num（学号）
        cout << "子类的_num：" << _num << endl; // 输出 111
        // 想访问父类的_num：必须加'基类::'
        cout << "父类的_num：" << Person::_num << endl; // 输出 123456
    }
protected:
    int _num = 111; // 学号
};

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

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);          // 调用子类的 fun(int)
    // b.fun();         // 编译报错：父类的 fun() 被隐藏了
    b.A::fun();         // 显式调用父类的 fun()
    return 0;
}

四、派生类的默认成员函数

子类有 6 个默认成员函数，但子类的处理逻辑必须先完成父类的部分。

1. 构造函数：先父后子

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

基类有默认构造函数：

class Person {
public:
    Person(const char* name = "张三") :_name(name) {
        cout << "Person()" << endl;
    }
protected:
    string _name;
};

class Student : public Person {
protected:
    int _num;
};

int main() {
    Student s1; // 自动调用 Person 默认构造
    return 0;
}

基类没有默认构造函数：

class Person {
public:
    Person(const char* name) :_name(name) {
        cout << "Person()" << endl;
    }
protected:
    string _name;
};

class Student : public Person {
public:
    Student(const char* name, int num) 
        : Person(name), _num(num) { // 必须在初始化列表显式调用
        cout << "Student()" << endl;
    }
protected:
    int _num;
};

int main() {
    Student s1("李四", 20);
    return 0;
}

2. 拷贝构造：先父后子

派生类的拷贝构造函数必须调用基类的拷贝构造。

class Person {
public:
    Person(const Person& p) :_name(p._name) {
        cout << "Person(const Person&)" << endl;
    }
protected:
    string _name;
};

class Student : public Person {
public:
    Student(const Student& s) 
        : Person(s), _num(s._num) { // 调用父类拷贝构造
        cout << "Student(const Student&)" << endl;
    }
protected:
    int _num;
};

int main() {
    Student s1("李四", 20);
    Student s2(s1); // 先拷贝 Person 部分，再拷贝 Student 部分
    return 0;
}

3. 赋值重载：先父后子

派生类的 operator= 必须调用基类的 operator=。注意同名函数会构成隐藏，需指定基类作用域。

class Person {
public:
    Person& operator=(const Person& p) {
        if (this != &p) _name = p._name;
        return *this;
    }
protected:
    string _name;
};

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

int main() {
    Student s1("李四", 20);
    Student s3("王五", 18);
    s1 = s3; // 先执行基类赋值，再执行子类赋值
    return 0;
}

4. 析构函数：先子后父

派生类的析构函数被调用完成后，自动调用基类的析构函数清理基类成员。顺序是先析构子类，再析构父类。

class Person {
public:
    ~Person() { cout << "~Person()" << endl; }
protected:
    string _name;
};

class Student : public Person {
public:
    ~Student() {
        cout << "~Student()" << endl;
        // 不需要显式调用父类析构，编译器会自动处理
    }
protected:
    int _num;
};

int main() {
    Student s1("李四", 20);
    return 0; // 析构顺序：~Student -> ~Person
}

5. 实现一个不能被继承的类

• 方法一（C++98）：将基类的构造函数设为私有。派生类无法访问基类构造，导致无法实例化。
• 方法二（C++11）：使用 final 关键字修饰基类。class Base final，任何类都不能继承它。

class Base final {
public:
    void func() { cout << "Base::func" << endl; }
};

class Derive : Base { }; // 编译错误：不能继承 final 类

参考资料

• C++ Reference
• cplusplus.com