三个类摆在一起,重复最扎眼。Student 和 Teacher 各自写着姓名、地址、电话、年龄,各自实现一份 identity()。把这些公共成员抽到 Person,两个角色只留自己的差异:

#include <string>
 
class Person
{
public:
    void identity() { /* 刷码认证 */ }
protected:
    std::string _name = "张三";
    std::string _address;
    std::string _tel;
    int _age = 18;
};
 
class Student : public Person
{
public:
    void study() { /* 学习 */ }
protected:
    int _stuid = 0;
};
 
class Teacher : public Person
{
public:
    void teaching() { /* 授课 */ }
protected:
    std::string _title;
};

定义格式就是 class 派生类 : 继承方式 基类,Student 是派生类(子类),Person 是基类(父类)。函数复用是把一段逻辑抽成函数,继承复用是把一批成员抽成类。

继承定义的三段:冒号左边是派生类,冒号右边是继承方式,再右边是基类名

权限矩阵:min(成员权限, 继承方式)

基类成员 \ 继承方式public 继承protected 继承private 继承
publicpublicprotectedprivate
protectedprotectedprotectedprivate
private不可见不可见不可见

非私有成员在派生类里的权限,等于它在基类里的权限与继承方式中更严格的那个,顺序是 public > protected > private。基类的 private 成员用哪种方式继承都不可见——不可见指的是名字在派生类作用域里查不到,不是对象里没有这块内存。

protected 基本上是为继承而生的:类外访问不到,派生类里可以直接用。这也是它和 private 唯一的实际区别。三条配套规则:

  • 用 class 定义时默认继承方式是 private,用 struct 时默认是 public,最好显式写出。
  • 实际工程里几乎只用 public 继承。protected/private 继承下来的成员只能在派生类内部用,扩展性差,也不表达“是”的关系。
  • 只有 public 继承允许在类外把派生类对象当基类用。

派生类对象里住着基类子对象

派生类对象由两部分组成:基类子对象,加上派生类自己新增的成员。基类子对象通常排在前面,具体偏移由 ABI 决定。这解释了三条转换规则。

派生类对象可以赋给基类的指针或引用,不需要加 const,也不产生临时对象:

#include <string>
 
class Person
{
protected:
    std::string _name, _sex;
    int _age;
};
 
class Student : public Person
{
public:
    int _No;
};
 
int main()
{
    Student sobj;
    Person* pp = &sobj;   // 指针指向 sobj 里的 Person 子对象
    Person& rp = sobj;    // 引用绑定同一块子对象
    Person pobj = sobj;   // 调用 Person 的拷贝构造,只复制基类那一段
    // sobj = pobj;       // 编译错误:基类对象不能赋给派生类对象
    Student* sp = static_cast<Student*>(pp);   // 反向转换,只在 pp 确实指向 Student 时安全
    return 0;
}

普通类型之间用引用绑定时往往要产生临时对象、于是要加 const,int a = 1; const double& d = a; 就是这种情况。派生类到基类的绑定是例外,因为它绑的就是对象里已经存在的那个基类子对象。

上两图:基类指针和引用都指向 Student 对象里红色的 Person 子对象,黄色那块 _No 不参与;下图:Person 对象只复制红色那一段,派生部分被丢掉

Person pobj = sobj; 这一步叫切片(slicing)。基类的拷贝构造或赋值运算符只处理基类子对象,派生类新增的成员根本不在目标对象的表示范围里,所以被切掉的是派生类那一部分,基类对象本身是完整的。如果基类有多态,切片后对象的虚表指针指向基类的虚表,虚调用回到基类版本。

反方向不安全。基类指针/引用可以强制转换成派生类指针/引用,但只有它实际指向派生类对象时才合法,上面的 static_cast<Student*>(pp) 属于这一类。static_cast 不做运行时检查,编译器不会拦下“pp 其实指向一个 Person”的情况,用错就是未定义行为。基类是多态类型时改用 dynamic_cast,它依赖 RTTI 做运行时识别,转换失败对指针返回空、对引用抛 std::bad_cast。

同名成员隐藏,函数名相同就够

基类和派生类是两个独立作用域。派生类里出现与基类同名的成员,基类那个名字在派生类作用域里就被屏蔽了,这叫隐藏。成员变量同名时,派生类里直接写名字拿到的是自己的,想用基类的要限定类域:

#include <iostream>
#include <string>
 
class Person
{
protected:
    std::string _name = "小李子";
    int _num = 111;          // 身份证号
};
 
class Student : public Person
{
public:
    void Print()
    {
        std::cout << _name << '\n'
                  << Person::_num << '\n'   // 基类的 _num
                  << _num << '\n';          // 派生类的 _num
    }
protected:
    int _num = 999;          // 学号
};

成员函数的隐藏更彻底:只要函数名相同就构成隐藏,参数列表、返回值都不参与判断。基类里所有同名重载会一起被挡住,派生类作用域里一个都看不见。

#include <iostream>
 
class A
{
public:
    void fun() { std::cout << "A::fun()\n"; }
};
 
class B : public A
{
public:
    void fun(int i) { std::cout << "B::fun(int)\n"; }
};
 
int main()
{
    B b;
    b.fun(10);      // 调用 B::fun(int)
    // b.fun();     // 编译错误:A::fun 已被 B::fun 隐藏
    b.A::fun();     // 显式限定才能调到基类版本
}

这三行就是课件那道选择题的答案:两个 fun 不是重载(不在同一作用域),是隐藏;b.fun() 编译不过,因为名字查找先在 B 里找到 fun,然后停住,不再往基类找。

派生类的默认成员函数,每一项都要带上基类

六个默认成员函数里,构造函数、拷贝构造、赋值重载、析构函数在派生类中都不是独立工作,它们必须处理基类那一份。

  1. 派生类构造函数必须调用基类构造函数。基类没有默认构造时,只能在派生类构造函数的初始化列表里显式调用。
  2. 派生类拷贝构造必须调用基类拷贝构造,完成基类子对象的拷贝初始化。
  3. 派生类 operator= 必须调用基类 operator=。派生类的 operator= 会隐藏基类的那个,所以要写成 Person::operator=(s)。
  4. 派生类析构函数执行完自己的函数体后,会自动调用基类析构函数。
  5. 构造顺序是基类先、派生类后;析构顺序正好相反。
  6. 析构函数在重写判断上按同一个名字看待:基类析构带 virtual 时,派生类析构会重写它;不带 virtual 时两者构成隐藏。隐藏的后果在 delete 上:通过基类指针删除派生类对象时,只会调基类析构,派生类那份资源释放不掉。

六个默认成员函数里剩下两个是取地址运算符重载(普通对象和 const 对象各一个),编译器自动生成,业务代码里几乎不会自己写。

构造从基类开始向下、析构从派生类开始向上;两边都是“先基类后派生”和“先派生后基类”的镜像关系

#include <iostream>
#include <string>
 
class Person
{
public:
    explicit Person(const std::string& name = "peter") : _name(name)
    { std::cout << "Person()\n"; }
 
    Person(const Person& p) : _name(p._name)
    { std::cout << "Person(const Person&)\n"; }
 
    Person& operator=(const Person& p)
    {
        std::cout << "Person::operator=\n";
        if (this != &p) _name = p._name;
        return *this;
    }
 
    ~Person() { std::cout << "~Person()\n"; }
protected:
    std::string _name;
};
 
class Student : public Person
{
public:
    Student(const std::string& name, int num) : Person(name), _num(num)
    { std::cout << "Student()\n"; }
 
    Student(const Student& s) : Person(s), _num(s._num)
    { std::cout << "Student(const Student&)\n"; }
 
    Student& operator=(const Student& s)
    {
        std::cout << "Student::operator=\n";
        if (this != &s)
        {
            Person::operator=(s);   // 基类版本被隐藏,必须限定
            _num = s._num;
        }
        return *this;
    }
 
    ~Student() { std::cout << "~Student()\n"; }
protected:
    int _num;
};
 
int main()
{
    Student s1("jack", 18);   // Person() 然后 Student()
    Student s2(s1);           // Person(const Person&) 然后 Student(const Student&)
    Student s3("rose", 17);   // Person() 然后 Student()
    s1 = s3;                  // Student::operator= 然后 Person::operator=
}

Student s2(s1) 调 Person(s) 时,s 是 Student,形参是 const Person&,这里发生了一次隐式的派生类到基类绑定,不会切片——Person 的拷贝构造拿到的仍然是 s1 里的基类子对象。真正切片的是用派生类对象初始化一个基类对象。

不能被继承的类、友元与静态成员

final 修饰类,这个类就不能再被继承:

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

C++98 没有 final,做法是把基类构造函数放到 private:派生类构造时必须调用基类构造,看不见就调不了,派生类无法实例化,效果等同于不可继承。

友元关系不继承。基类的友元能访问基类的私有/保护成员,但不能访问派生类的成员:

#include <iostream>
#include <string>
 
class Student;
 
class Person
{
    friend void Display(const Person& p, const Student& s);
protected:
    std::string _name;
};
 
class Student : public Person
{
protected:
    int _stuNum = 0;
};
 
void Display(const Person& p, const Student& s)
{
    std::cout << p._name;     // 可以
    // std::cout << s._stuNum; // 编译错误:Display 不是 Student 的友元
}

基类的静态成员在整个继承体系里只有一份。Person 里声明 static int _count;,那么 Person::_count 和 Student::_count 是同一个变量,取地址得到同一个值;非静态成员则是每个对象各一份。

继承类模板时,基类成员要通过 this 找

#include <vector>
 
template<class T>
class Stack : public std::vector<T>
{
public:
    void push(const T& x) { this->push_back(x); }
    void pop()             { this->pop_back(); }
    const T& top() const   { return this->back(); }
    bool empty() const     { return std::vector<T>::empty(); }
};

直接把 push_back(x) 写成不带 this-> 的形式,GCC、Clang 和开了 /permissive- 的 MSVC 都会报“找不到标识符”。课件把原因写成“模板按需实例化,push_back 等成员函数未实例化所以找不到”,这个解释不对。真正的原因是两阶段名字查找(two-phase lookup):Stack<T> 的基类 std::vector<T> 是依赖基类(dependent base),它的成员在模板定义阶段无法确定,标准规定非限定查找不会进入依赖基类,所以名字在 Stack<T> 的作用域里根本查不到。this->push_back(x) 和 std::vector<T>::push_back(x) 都是把查找推迟到实例化阶段。

顺带说一句,这个 Stack 只是课件用来演示名字查找的例子。真把 std::vector 当基类,等于把 operator[]、insert、迭代器全部暴露出去,“只能从一端进出”的约束就没了,实际实现用组合更好。

菱形继承:两份 Person 与 virtual 的代价

一个派生类有两个或以上直接基类叫多继承。对象布局通常是先继承的基类在前,后继承的在后,派生类自己的成员排在末尾(这是主流 ABI 的做法,标准不规定具体偏移)。多继承一放开,菱形继承就一定会被设计出来,Java 干脆不支持多继承,也就没有这个问题。

菱形继承是多继承的特殊情况:

#include <string>
 
class Person { public: std::string _name; };
class Student : public Person { protected: int _num; };
class Teacher : public Person { protected: int _id; };
class Assistant : public Student, public Teacher { protected: std::string _majorCourse; };

菱形的类图:Assistant 同时继承 Student 和 Teacher,两条路径各自带下来一个 Person,于是对象里有两份 _name

Assistant 对象里有两个完整的 Person 子对象。直接写 a._name = "peter" 报 error C2385: 对"_name"的访问不明确,因为编译器不知道指哪一份。a.Student::_name 和 a.Teacher::_name 能编译,二义性解决了,数据冗余还在:两份 _name 各自存一份值,改一份不影响另一份。

虚继承让两条路径共享同一个基类子对象:

class Student : virtual public Person { protected: int _num; };
class Teacher : virtual public Person { protected: int _id; };

此时 Assistant 里只有一个 Person,a._name 不再有二义性。代价是对象里多了虚基类指针或偏移信息,访问虚基类成员要多一次间接,构造也更绕:虚基类由最派生类直接初始化,中间层构造函数的初始化列表对虚基类无效。

#include <iostream>
#include <string>
 
class Person
{
public:
    explicit Person(const std::string& name) : _name(name)
    { std::cout << "Person: " << _name << '\n'; }
 
    std::string _name;
};
 
class Student : virtual public Person
{
public:
    Student(const std::string& name, int num) : Person(name), _num(num) {}
protected:
    int _num;
};
 
class Teacher : virtual public Person
{
public:
    Teacher(const std::string& name, int id) : Person(name), _id(id) {}
protected:
    int _id;
};
 
class Assistant : public Student, public Teacher
{
public:
    Assistant(const std::string& name1, const std::string& name2, const std::string& name3)
        : Person(name3)          // 虚基类由 Assistant 自己初始化
        , Student(name1, 1)
        , Teacher(name2, 2)
    {}
protected:
    std::string _majorCourse;
};
 
int main()
{
    Assistant a("张三", "李四", "王五");
    std::cout << a._name << '\n';      // 王五,整个对象只有这一份
}

Student 和 Teacher 构造函数里的 Person(name) 在构造 Assistant 时被忽略:虚基类的初始化权归最派生类,否则它会被初始化两次。虚继承的代价不止构造:对象里要存虚基类的定位信息,访问虚基类成员多一层间接,布局也更复杂。能通过重构避开菱形关系时,优先重构。

标准库的 IO 体系就是菱形虚拟继承:basic_ios 是 basic_ostream 和 basic_istream 的虚基类,basic_iostream 同时继承后两者,只共享一份 basic_ios。

IO 继承体系:basic_ostream 与 basic_istream 虚继承 basic_ios,basic_iostream 再把两边合起来;没有 virtual 这一层,合起来时就会出现两份 basic_ios

多继承指针偏移也值得看一眼:

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
 
int main()
{
    Derive d;
    Base1* p1 = &d;
    Base2* p2 = &d;
    Derive* p3 = &d;
    return 0;
}

在 MSVC 和 Itanium ABI 下,Base1 子对象在偏移 0,Base2 子对象在偏移 4,所以 p1 == p3,p2 比它们大 4,答案是 p1 == p3 != p2。标准不保证布局,这个结论是编译器实现的结论,不是语言规则。

继承是白箱,组合是黑箱

public 继承表达 is-a:每个派生类对象都是基类对象。组合表达 has-a:B 里有一个 A 成员。

继承是白箱复用:基类的实现细节对派生类可见,派生类和基类的依赖很强,基类改一点,派生类可能跟着坏,封装被破坏。组合是黑箱复用:被组合的对象只以接口出现,内部细节不可见,两边耦合低。

class Tire { /* 品牌、尺寸 */ };
 
class Car
{
protected:
    Tire _t1, _t2, _t3, _t4;   // has-a
};
 
class BMW : public Car { };   // is-a

Car 和 Tire 是 has-a,BMW 和 Car 是 is-a。Stack 和 vector 两种关系都沾一点,但按 has-a 处理——组合一个 vector 成员,而不是继承它。

选择顺序:优先组合;确实表达 is-a 时用继承;需要多态时必须有继承,因为虚函数调用要靠基类指针/引用。两者都说得通时,选组合,耦合度低,维护成本小。