1. 继承的本质与价值：为什么我们需要继承？
在软件开发中，我们经常会遇到这样的场景：多个类具有相同的属性和行为。比如在学校管理系统中，Student（学生）和Teacher（教师）都需要姓名、地址和身份认证功能，但学生有学号，教师有职称。如果为每个类都重复编写这些公共部分，不仅代码冗余，维护起来也相当麻烦。
继承（Inheritance）就是为解决这类问题而生的。它允许我们创建一个基类（Base Class，也称为父类）来包含这些公共成员，然后让派生类（Derived Class，也称为子类）继承基类并添加自己特有的成员。这种机制完美体现了面向对象编程中的"代码复用"原则。
提示：在实际项目中，继承的使用需要谨慎。过度使用继承会导致类层次结构过于复杂，反而增加维护难度。一般来说，当两个类之间存在"is-a"关系（如"学生是人"）时，才考虑使用继承。
2. 继承的基本语法与访问控制
2.1 继承的定义方式
C++中继承的基本语法如下：
cpp复制class DerivedClass : access-specifier BaseClass {
// 类成员声明
};
其中，access-specifier可以是public、protected或private，决定了基类成员在派生类中的访问权限。
关键点：
- 使用
class关键字定义类时，默认继承方式是private - 使用
struct关键字定义类时，默认继承方式是public - 最佳实践是显式指定继承方式，即使它与默认值相同
2.2 三种继承方式详解
2.2.1 public继承（最常用）
cpp复制class Student : public Person {
// ...
};
public继承是最常用的继承方式，它建立了"is-a"关系，即派生类对象确实是基类的一种特殊类型。
2.2.2 protected继承
cpp复制class Student : protected Person {
// ...
};
protected继承在实际开发中很少使用，它表示派生类"以受保护的方式实现"基类的功能。
2.2.3 private继承
cpp复制class Student : private Person {
// ...
};
private继承表示派生类"以私有方式实现"基类的功能，通常用于实现"has-a"关系（组合关系）的另一种表达方式。
2.3 成员访问权限规则
继承方式与基类成员访问修饰符共同决定了成员在派生类中的最终访问权限。规则可以总结为：
最终访问权限 = min(基类中的访问权限, 继承方式)
具体规则如下表所示：
| 基类成员访问权限 | public继承 | protected继承 | private继承 |
|---|---|---|---|
| public | public | protected | private |
| protected | protected | protected | private |
| private | 不可访问 | 不可访问 | 不可访问 |
注意：基类的private成员在派生类中是不可见的，但这并不意味着它们不存在。派生类对象仍然包含这些成员，只是不能直接访问。
3. 继承中的默认成员函数
3.1 构造函数与析构函数
在继承体系中，构造函数和析构函数的调用遵循特定规则：
-
派生类对象的构造顺序：
- 先调用基类的构造函数
- 然后调用派生类成员的构造函数
- 最后调用派生类自身的构造函数体
-
派生类对象的析构顺序：
- 先执行派生类的析构函数体
- 然后调用派生类成员的析构函数
- 最后调用基类的析构函数
示例代码：
cpp复制class Person {
public:
Person(const string& name) : _name(name) {
cout << "Person constructor: " << _name << endl;
}
~Person() {
cout << "Person destructor: " << _name << endl;
}
private:
string _name;
};
class Student : public Person {
public:
Student(const string& name, int id)
: Person(name), _id(id) {
cout << "Student constructor: " << _id << endl;
}
~Student() {
cout << "Student destructor: " << _id << endl;
}
private:
int _id;
};
int main() {
Student s("Alice", 1001);
return 0;
}
输出结果：
code复制Person constructor: Alice
Student constructor: 1001
Student destructor: 1001
Person destructor: Alice
3.2 拷贝构造函数与赋值运算符
派生类的拷贝操作需要特别注意基类部分的处理：
cpp复制class Student : public Person {
public:
// 拷贝构造函数
Student(const Student& other)
: Person(other), // 调用基类的拷贝构造函数
_id(other._id) {
cout << "Student copy constructor" << endl;
}
// 赋值运算符
Student& operator=(const Student& other) {
if (this != &other) {
Person::operator=(other); // 调用基类的赋值运算符
_id = other._id;
cout << "Student assignment operator" << endl;
}
return *this;
}
private:
int _id;
};
常见错误：忘记在派生类的拷贝操作中调用基类的对应操作，导致基类部分成员没有被正确拷贝。
4. 继承中的名称查找与隐藏
4.1 名称查找规则
在继承体系中，名称查找遵循以下顺序：
- 先在派生类的作用域中查找
- 如果没找到，再到基类的作用域中查找
- 如果基类中也没找到，再到更上层的基类中查找（如果是多继承）
- 最后在全局作用域中查找
4.2 名称隐藏
如果派生类定义了与基类同名的成员（函数或变量），基类的成员会被隐藏：
cpp复制class Base {
public:
void func() { cout << "Base::func()" << endl; }
};
class Derived : public Base {
public:
void func(int) { cout << "Derived::func(int)" << endl; }
};
int main() {
Derived d;
d.func(1); // 正确：调用Derived::func(int)
// d.func(); // 错误：Base::func()被隐藏
d.Base::func(); // 正确：显式指定调用基类函数
return 0;
}
要解决名称隐藏问题，可以使用using声明：
cpp复制class Derived : public Base {
public:
using Base::func; // 将Base::func引入当前作用域
void func(int) { cout << "Derived::func(int)" << endl; }
};
5. 继承中的常见问题与解决方案
5.1 菱形继承问题
当多个派生类继承自同一个基类，然后又有类多继承这些派生类时，会出现菱形继承问题：
code复制 Base
/ \
Derived1 Derived2
\ /
MoreDerived
这会导致MoreDerived中包含两份Base的子对象，可能引发数据冗余和二义性。
解决方案是使用虚继承：
cpp复制class Base { /*...*/ };
class Derived1 : virtual public Base { /*...*/ };
class Derived2 : virtual public Base { /*...*/ };
class MoreDerived : public Derived1, public Derived2 { /*...*/ };
5.2 基类指针与派生类对象
基类指针可以指向派生类对象，这是多态的基础：
cpp复制Person* p = new Student("Bob", 1002);
// 可以通过p访问Person的成员
p->identity();
delete p; // 如果Person的析构函数不是虚函数，这里会有问题
重要规则：当基类中有虚函数时，应该将基类的析构函数也声明为虚函数，否则通过基类指针删除派生类对象会导致派生类部分的资源泄漏。
5.3 类型转换
C++提供了几种类型转换操作符：
static_cast：用于良性转换，如数值类型转换、基类指针与派生类指针间的转换dynamic_cast：用于安全地沿继承层次结构向下转换（需要运行时类型检查）const_cast：用于移除const属性reinterpret_cast：用于低层次的重新解释（危险，慎用）
在继承体系中最常用的是dynamic_cast：
cpp复制Person* p = new Student("Charlie", 1003);
if (Student* s = dynamic_cast<Student*>(p)) {
// 转换成功，p确实指向Student对象
s->study();
} else {
// 转换失败
}
6. 继承的最佳实践
-
优先使用组合而非继承：只有在确实需要表达"is-a"关系时才使用继承，否则考虑使用组合。
-
遵循LSP原则：里氏替换原则(Liskov Substitution Principle)指出，派生类对象应该能够替换基类对象而不影响程序的正确性。
-
保持继承层次扁平：过深的继承层次会增加复杂度，一般不超过3层。
-
避免多重继承：除非必须使用接口类（纯虚类），否则避免多重继承。
-
为多态基类声明虚析构函数：如果一个类可能被继承，并且会通过基类指针删除派生类对象，那么它的析构函数应该是虚函数。
-
谨慎使用protected成员：protected成员破坏了封装性，只有在确实需要让派生类访问时才使用。
-
考虑使用final关键字：C++11引入的final关键字可以防止类被继承或虚函数被重写。
cpp复制class NotInheritable final {
// 这个类不能被继承
};
class Base {
public:
virtual void func() final; // 这个虚函数不能在派生类中被重写
};
在实际项目中，合理使用继承可以大幅提高代码的复用性和可维护性，但滥用继承会导致系统变得复杂难懂。掌握继承的核心概念和最佳实践，是成为优秀C++程序员的重要一步。