西嘎嘎学习 - C++ 继承 - Day 10

1  什么是继承

        继承是面向对象编程中的一个重要特性，它允许一个类（派生类）从另一个类（基类）中继承属性和方法，可以实现代码的复用，提高开发效率。

2  基类与派生类

        基类：被继承的类，也叫父类。

        派生类：继承基类的类，也叫子类。

#include <iostream>
using namespace std;

// 基类
class Animal {
public:
    void eat()
    {
        cout << "Animal is eating" << endl;
    }
};

// 派生类
class Dog : public Animal {
public:
    void bark()
    {
        cout << "Dog is barking" << endl;
    }
};

int main()
{
    Dog myDog;
    myDog.eat();     // 继承自 Animal
    myDog.bark();    // Dog 自己的方法

    return 0;
}

        输出：

Animal is eating.
Dog is barking.

3  访问控制和继承

        在继承中，访问控制非常重要，它决定了派生类如何访问基类的成员。

（1）基类成员的访问权限

        基类中的成员可以是：

          1.public：公共成员，可以被派生类访问。

          2.protected：受保护成员，只能被派生类访问。

          3.private：私有成员，不能被派生类访问。

  （2）继承方式（访问控制符）

        继承时可以指定继承方式，这会影响基类成员在派生类中的访问权限。

#include <iostream>
using namespace std;

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;
};

class Derived : public Base {
public:
    void accessMembers() {
        publicVar = 1;        // 允许
        protectedVar = 2;     // 允许
        // privateVar = 3;   // 错误！private成员不可访问
    }
};

int main() {
    Derived d;
    d.publicVar = 10;         // 允许
    // d.protectedVar = 20;  // 错误！protected成员在类外不可访问
    return 0;
}

4  继承类型

        1.public 继承（共有继承）：最常用，基类的 public 成员在派生类中仍为 public。

        2.protected 继承：基类的 public 和 protected 成员在派生类中都变为 protected。

        3.private 继承：基类的 public 和 protected 成员在派生类中都变为 private。

        示例（public 继承）：

#include <iostream>
using namespace std;

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

class Derived : public Base {
    // 继承 Base 的所有 public 成员
};

int main()
{
    Derived d;
    d.show();   // 正确调用
    
    return 0;
}

5  多继承

        从多个基类继承，称为多继承。

        语法：

class Derived : public Base1 ,public Base 2 {
    // ...
};

        示例：

#include <iostream>
using namespace std;

class Animal {
public:
    void eat()
    {
        cout << "Animal is eating" << endl;
    }
};

class Mammal {
public:
    void breathe()
    {
        cout << "Mammal is breathe." << endl;
    }
};

class Dog : public Animal, public Mammal {
public:
    void bark()
    {
        cout << "Dog is barking" << endl;
    }
};

int main()
{
    Dog myDog;
    myDog.eat();    // 继承自 animal
    myDog.breathe();    // 继承自mammal
    myDog.bark();   // Dog 自己的方法

    return 0;
}

6  继承中的构造函数和析构函数

  （1）构造函数调用顺序

        1.基类构造函数 -> 派生类构造函数

        2.如果是多继承，基类构造函数按声明顺序调用

#include <iostream>
using namespace std;

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

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

int main()
{
    Derived d;

    return 0;
}

  （2）析构函数调用顺序

        与构造函数相反：派生类析构函数 -> 基类析构函数

7  虚继承

        在多继承中，如果两个基类都继承自同一个类，可能会导致菱形继承问题。

        示例（菱形继承）：

class A {
public:
    int x;
};

class B : public A {};
class C : public A {};
class D : public B, public C {};

        此时，D 有两个 x，一个来自 B，一个来自 C，容易出错。

        解决方法：使用 virtual 继承：

class A {
public:
    int x;
};

class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {};

        这样，D 就只有一个 x，避免了重复继承。

8  总结