第二节 · 宗族的继承 · 基类与派生类

继承是面向对象的核心概念之一，它允许我们基于已有的类创建新类，复用代码并建立类之间的层次关系。

---

基本继承

// 基类（父类）
class Animal
{
protected:
    string name;
    
public:
    Animal(const string& n) : name(n) {}
    
    void eat()
    {
        cout << name << " is eating." << endl;
    }
};

// 派生类（子类）
class Dog : public Animal
{
public:
    Dog(const string& n) : Animal(n) {}  // 调用基类构造函数
    
    void bark()
    {
        cout << name << " says: Woof!" << endl;
    }
};

int main()
{
    Dog d("Buddy");
    d.eat();   // 继承自 Animal
    d.bark();  // Dog 自己的方法
    
    return 0;
}

---

继承方式

继承方式	基类 public	基类 protected	基类 private
public	public	protected	不可访问
protected	protected	protected	不可访问
private	private	private	不可访问

class Base
{
public:
    int pub;
protected:
    int prot;
private:
    int priv;
};

class PublicDerived : public Base
{
    // pub 是 public
    // prot 是 protected
    // priv 不可访问
};

class PrivateDerived : private Base
{
    // pub 是 private
    // prot 是 private
    // priv 不可访问
};

最常用的是 public 继承。

---

构造和析构顺序

class Base
{
public:
    Base() { cout << "Base constructor" << endl; }
    ~Base() { cout << "Base destructor" << endl; }
};

class Derived : public Base
{
public:
    Derived() { cout << "Derived constructor" << endl; }
    ~Derived() { cout << "Derived destructor" << endl; }
};

int main()
{
    Derived d;
    // 输出：
    // Base constructor
    // Derived constructor
    // Derived destructor
    // Base destructor
    
    return 0;
}

规则：构造从基类到派生类，析构从派生类到基类。

---

方法覆盖

class Shape
{
public:
    void draw()
    {
        cout << "Drawing a shape" << endl;
    }
};

class Circle : public Shape
{
public:
    void draw()  // 覆盖基类方法
    {
        cout << "Drawing a circle" << endl;
    }
};

int main()
{
    Circle c;
    c.draw();  // Drawing a circle
    
    c.Shape::draw();  // 调用基类版本：Drawing a shape
    
    return 0;
}

---

调用基类构造函数

class Person
{
protected:
    string name;
    int age;
    
public:
    Person(const string& n, int a) : name(n), age(a) {}
};

class Student : public Person
{
private:
    string school;
    
public:
    // 必须在初始化列表中调用基类构造函数
    Student(const string& n, int a, const string& s)
        : Person(n, a), school(s)
    {
    }
    
    void introduce()
    {
        cout << name << ", " << age << " years old, studies at " 
             << school << endl;
    }
};

---

protected 成员

class Base
{
protected:
    int value;  // 派生类可以访问
    
public:
    Base(int v) : value(v) {}
};

class Derived : public Base
{
public:
    Derived(int v) : Base(v) {}
    
    void increment()
    {
        value++;  // OK：protected 在派生类中可访问
    }
    
    int getValue() const { return value; }
};

int main()
{
    Derived d(10);
    // d.value = 20;  // 错误：外部不能访问 protected
    d.increment();
    cout << d.getValue() << endl;  // 11
    
    return 0;
}

---

多层继承

class Grandparent
{
public:
    void methodA() { cout << "Grandparent::methodA" << endl; }
};

class Parent : public Grandparent
{
public:
    void methodB() { cout << "Parent::methodB" << endl; }
};

class Child : public Parent
{
public:
    void methodC() { cout << "Child::methodC" << endl; }
};

int main()
{
    Child c;
    c.methodA();  // 继承自 Grandparent
    c.methodB();  // 继承自 Parent
    c.methodC();  // Child 自己的
    
    return 0;
}

---

is-a 关系

继承表达的是 "is-a" 关系：

// Dog is an Animal
class Dog : public Animal {};

// Circle is a Shape
class Circle : public Shape {};

// Student is a Person
class Student : public Person {};

如果不是 "is-a" 关系，考虑用组合而非继承：

// Car has an Engine（不是 Car is an Engine）
class Car
{
private:
    Engine engine;  // 组合
};

---

隐藏基类成员

class Base
{
public:
    void foo() { cout << "Base::foo()" << endl; }
    void foo(int x) { cout << "Base::foo(" << x << ")" << endl; }
};

class Derived : public Base
{
public:
    void foo()  // 隐藏了基类所有 foo
    {
        cout << "Derived::foo()" << endl;
    }
};

int main()
{
    Derived d;
    d.foo();       // OK: Derived::foo()
    // d.foo(42);  // 错误：被隐藏了
    
    d.Base::foo(42);  // OK：显式调用基类版本
    
    return 0;
}

用 using 声明可以恢复：

class Derived : public Base
{
public:
    using Base::foo;  // 引入基类的 foo
    void foo() { cout << "Derived::foo()" << endl; }
};

---

习题

• 设计一个形状类层次结构：Shape → Rectangle, Circle, Triangle。

• 解释 public、protected、private 继承的区别。

• 什么时候应该用继承，什么时候用组合？