C++ 继承的核心逻辑：复用、隐藏与默认成员函数

继承方式与访问权限

基类成员在派生类中的权限由'基类访问限定符'和'继承方式'共同决定，取两者中更严格的（public > protected > private）。实际开发几乎只用 public 继承，所以我只重点记这个表：

• 基类 private 成员无论如何都不可见，只能通过基类的 public 成员间接访问。
• protected 就是为继承设计的，类外不能访问，子类可以。
• protected/private 继承用得少，限制多，维护性不好。

拿栈举例子，用继承实现很方便：

namespace MyLib {
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() {
    MyLib::stack<int> st;
    st.push(1);
    st.push(2);
    st.push(3);
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    return 0;
}

从基类到派生类的类型转换

public 继承下，派生类对象可以隐式转换为基类指针或引用，这常被叫做'切片'——只切出基类那一部分。反过来不行，基类对象不能安全转成派生类对象。

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

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

int main() {
    Student sobj;
    Person* pp = &sobj;      // 基类指针指向派生类的基类部分
    Person& rp = sobj;       // 基类引用
    Person pobj = sobj;      // 拷贝构造，只拷贝基类部分

    // sobj = pobj;          // 错误，基类不能转派生类
    return 0;
}

只有当基类指针本来就指向派生类对象时，才能用强制转换（比如 dynamic_cast）安全地转回派生类指针，这个话题后面讲类型转换时再展开。

继承中的作用域与隐藏

每个类都有自己的作用域。派生类和基类出现同名成员（函数或变量）时，派生类的会隐藏基类的同名成员，这就是隐藏。

变量隐藏

class Person {
protected:
    string _name = "小李子";
    int _num = 111;   // 身份证号
};

class Student : public Person {
public:
    void Print() {
        cout << "子类的 _num：" << _num << endl;          // 输出 999
        cout << "父类的 _num：" << Person::_num << endl;  // 输出 111
    }
protected:
    int _num = 999;   // 学号
};

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

函数隐藏

函数隐藏只看名字，不管参数列表。这是最容易踩的坑。

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() 被隐藏了
    b.A::fun();      // 必须这样调用
    return 0;
}

所以现实编码中，尽量不要让基类和派生类有同名成员；如果不可避免，用 Base::member 显式指定。

派生类的默认成员函数

派生类的默认成员函数（构造、拷贝、赋值、析构）在处理自己的成员前，必须先处理基类部分。可以把基类部分看作一个整体成员，遵循和普通成员类似的原则。

默认生成的派生类构造：内置类型不确定，自定义类型调用默认构造，基类部分也调用默认构造。如果派生类有深拷贝资源，需要自己实现拷贝构造和赋值重载。

构造函数：先父后子

派生类构造时，先调用基类的构造，再初始化自己的成员。如果基类没有默认构造，必须在初始化列表里显式调用。

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

拷贝构造：调用基类拷贝

派生类拷贝构造时，先用基类的拷贝构造复制基类部分，再复制自己的成员。

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

class Student : public Person {
public:
    Student(const Student& s) : Person(s), _num(s._num), _address(s._address) {}
protected:
    int _num;
    string _address;
};

赋值重载：先调基类的 operator=

派生类的赋值重载会隐藏基类的赋值重载，所以要显式调用 Base::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;
            _address = s._address;
        }
        return *this;
    }
protected:
    int _num;
    string _address;
};

析构函数：先子后父

派生类析构时，先执行自己的析构，然后编译器自动调用基类的析构。别在派生类析构里手动调用 Base::~Base()，否则会析构两次。

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

class Student : public Person {
public:
    ~Student() {
        cout << "~Student()" << endl;
        // 编译器自动调用 Person::~Person()
    }
protected:
    int _num;
};

int main() {
    Student s1;
    return 0;
}

禁止继承

有时不希望某个类被继承，两种做法：

• C++98：把构造函数私有
• C++11：用 final

// C++98
class Base {
    Base() {}
};

// C++11
class Base final { … };

回看这几个点，继承的核心就是复用：用 public 继承，注意访问权限、类型转换、作用域隐藏，处理默认成员函数时遵循先基类后派生类的顺序。先搞清楚这些，后面碰到多继承、虚继承时心里才有底。