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

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

父类成员在子类中的访问权限，取决于'父类的访问限定符'和'继承方式'。核心规则是：访问权限 = 两者中更严格的那个 (public > protected > private)。

注意以下几点：

1. 基类 private 成员在派生类中无论以什么方式继承都是不可见的。虽然它们被继承到了对象内存中，但语法上限制访问。
2. 如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为 protected。保护成员限定符是因继承才出现的。
3. 使用关键字 class 时默认的继承方式是 private，使用 struct 时默认的继承方式是 public。不过最好显式写出继承方式。
4. 实际运用中一般使用 public 继承，很少使用 protected/private 继承，因为后者继承下来的成员只能在派生类内部使用，扩展性不强。

这里用一个 Stack 的例子演示如何使用继承实现容器：

#include <iostream>
#include <vector>
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;
}

二、基类与派生类的转换

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

• 派生类对象 → 基类指针/引用：可以赋值，这叫切片（Slicing）。寓意把派生类中基类那部分切出来，基类指针指向的是派生类中切出来的基类那部分。
• 基类对象 → 派生类对象：不能赋值。基类没有子类的成员，强行转换会访问不存在的内容。
• 基类指针 → 派生类指针：可以通过强制类型转换，但必须确保基类指针确实指向派生类对象，否则不安全。

class Person {
protected:
    string _name;
    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.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& p)" << endl;
    }
protected:
    string _name;
};

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

int main() {
    Student s1("李四", 20);
    Student s2(s1); // 拷贝构造
    return 0;
}

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

派生类的 operator= 必须调用基类的 operator= 完成基类的复制。需要注意的是派生类的 operator= 隐藏了基类的 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);
    // 析构顺序：先~Student()，再~Person()
    return 0;
}

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

方法一：基类的构造函数私有（C++98）

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

class Base {
public:
    void func() { cout << "Base::func" << endl; }
protected:
    int a = 1;
private:
    Base() {} // 构造函数私有
};

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

方法二：添加 final 关键字（C++11）

final 修改基类，派生类就不能继承了。

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

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

总结

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

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

参考文档：

• https://zh.cppreference.com/w/cpp