C++ 继承机制详解：从概念定义到默认成员函数实现

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

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

注意以下几点：

1. 基类 private 成员在派生类中无论以什么方式继承都是不可见的。虽然它们被物理继承了，但语法上限制访问。
2. 使用关键字 class 时默认的继承方式是 private，使用 struct 时默认是 public。实际开发中建议显式写出继承方式，通常使用 public 继承。
3. 保护成员限定符是因继承才出现的，用于解决基类成员不想在类外直接被访问，但需要在派生类中能访问的场景。

在实际运用中，一般使用 public 继承。Protected/Private 继承下来的成员只能在派生类的类里面使用，扩展维护性不强，不提倡使用。

这里可以用 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;
}

二、基类与派生类的转换

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

• Upcasting（向上转换）：public 继承的派生类对象可以赋值给基类的指针/引用。这被称为切片（Slicing），寓意把派生类中基类那部分切出来。
• Downcasting（向下转换）：基类对象不能赋值给派生类对象。基类的指针或引用可以通过强制类型转换赋值给派生类的指针或引用，但必须确保基类指针确实指向派生类对象，否则不安全。

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; // 父类的_num：身份证号
};

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 {
public:
    // 默认生成的构造函数行为：
    // 1. 内置类型——> 不确定
    // 2. 自定义类型——> 调用对应的默认构造
    // 3. 继承父类成员看作一个整体对象，要求调用父亲的默认构造
protected:
    int _num;
    string _address;
};

int main() {
    Student s1;
    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 = 18, const char* address = "北京")
        : Person(name), _num(num), _address(address) {
        cout << "Student()" << endl;
    }
protected:
    int _num;
    string _address;
};

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

关键顺序：构造时 '先父后子' —— 父类先初始化，子类才能用父类的成员。

2. 拷贝构造：先拷贝父类，再拷贝子类

派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

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

class Student : public Person {
public:
    Student(const Student& s) : Person(s), _num(s._num), _address(s._address) {
        // 如果有深拷贝资源（比如 int*），这里要手动处理
    }
protected:
    int _num;
    string _address;
};

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

3. 赋值重载：先赋值父类，再赋值子类

派生类的 operator= 必须调用基类的 operator= 完成基类的复制。需要注意的是派生类的 operator= 隐藏了基类的 operator=，所以显示调用基类的 operator=，需要指定基类作用域。

class Person {
public:
    Person& operator=(const Person& p) {
        cout << "Person& operator=(const Person& p)" << endl;
        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;
            _address = s._address;
        }
        return *this;
    }
protected:
    int _num;
    string _address;
};

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

int main() {
    Student s1("李四", 20, "北京");
    // 析构顺序：先~Student()，再~Person()
    return 0;
}

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

方法一：基类的构造函数私有。派生类的构造必须调用基类的构造函数，但是基类的构造函数私有化以后，派生类不可访问也就不能调用了，那么派生类就无法实例化出对象。

class Base {
public:
    void func() { cout << "Base::func" << endl; }
protected:
    int a = 1;
private:
    Base() { }
};

class Derive : public Base { }; // 编译错误

方法二：C++11 新增了一个 final 关键字，final 修改基类，派生类就不能继承了。

class Base final {
public:
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
};

class Derive : public Base { }; // 编译错误

总结

继承的核心是'复用'与'扩展'，吃透单继承的权限规则、对象转换、同名隐藏及默认函数逻辑，就能避开多数基础陷阱。

1. 用 public 继承实现代码复用，区分 public/protected/private 的访问权限。
2. 记住'子类能转父类，父类不能转子类'，避免不安全转换。
3. 同名成员会隐藏，访问时加父类作用域。
4. 子类默认成员函数要先处理父类部分，尤其是构造和赋值重载。
5. 构造顺序：先父后子，析构顺序：先子后父。

参考文档

• https://legacy.cplusplus.com/reference/
• https://zh.cppreference.com/w/cpp
• https://en.cppreference.com/w/