【C++入门到精通】C++入门 —— 继承（基类、派生类和多态性）

前言

前面我们讲了C语言的基础知识，也了解了一些数据结构，并且讲了有关C++的命名空间的一些知识点以及关于C++的缺省参数、函数重载，引用 和 内联函数也认识了什么是类和对象以及怎么去new一个 ‘对象’ ，也了解了C++中的模版，以及学习了几个STL的结构也相信大家都掌握的不错，接下来博主将会带领大家继续学习有关C++比较重要的知识点—— 继承（基类、派生类和多态性）。下面话不多说坐稳扶好咱们要开车了

一、继承的概念及定义

1. 继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

注意：继承是一种强关联关系，因此在使用继承时需要仔细设计类之间的关系，避免产生紧耦合和不必要的依赖关系。

2.继承的定义

⭕定义格式

class 派生类名(子类): 访问修饰符 基类名(父类)
{
    // 子类的成员和方法
};

• class 关键字用于声明一个类。
• 派生类名 是你要定义的子类的名称。
• 访问修饰符 可以使用 public、protected 或 private，用于控制子类对父类成员的访问权限。
• 基类名 是你希望子类继承的父类的名称。

⭕继承关系和访问限定符

⭕继承基类成员访问方式的变化

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可

【总结】

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected> private。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

⭕下面是一个示例，演示如何定义一个子类 Square 继承父类 Shape：

class Shape
{
protected:
    int width;
    int height;
public:
    void setWidth(int w)
    {
        width = w;
    }
    void setHeight(int h)
    {
        height = h;
    }
};

class Square : public Shape
{
public:
    int getArea()
    {
        return width * height;
    }
};

在上述示例中，Square 继承了 Shape 的属性 width 和 height，并且定义了自己的方法 getArea() 来计算正方形的面积。使用 public 访问修饰符，使得 Square 类可以直接访问 Shape 类中的公共成员。

二、基类和派生类对象赋值转换

• 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
• 基类对象不能赋值给派生类对象。
• 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。如果要将基类对象转换为派生类对象，可以使用 dynamic_cast 进行类型转换，并且可能需要在转换之前进行运行时类型检查，以确保安全性。

class Person
{
protected :
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};

class Student : public Person
{
public :
	int _No ; // 学号
};

void Test ()
{
	Student sobj ;
	// 1.子类对象可以赋值给父类对象/指针/引用
	Person pobj = sobj ;
	Person* pp = &sobj;
	Person& rp = sobj;

	//2.基类对象不能赋值给派生类对象会报错
	sobj = pobj;//err

	//3.基类的指针可以通过强制类型转换赋值给派生类的指针
	pp = &sobj
	Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
	ps1->_No = 10;
	pp = &pobj;
	Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
	ps2->_No = 10;
}

三、继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类的作用域包含父类的作用域。
3. 父类的作用域不包含子类的作用域。
4. 子类可以直接访问父类的公共成员和受保护成员。
5. 父类不能直接访问子类的成员。（如果父类需要访问子类的成员，可以通过公共接口或子类的方法来实现）
6. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
7. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
8. 注意在实际中在继承体系里面最好不要定义同名的成员。

总结起来，继承中的作用域规则允许子类访问父类的成员，但父类不能直接访问子类的成员。这种作用域规则有助于实现封装和信息隐藏，提高代码的可维护性和安全性。

四、派生类的默认成员函数

⭕6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？下面我们来逐一分析：

1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。

注意：编译器会对析构函数名进行特殊处理，处理成destrutor()所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

⭕这六个默认成员函数在派生类中的生成规则与基类的可访问性有关。需要注意的是，如果派生类显式定义了上述任何一个成员函数，编译器将不会自动生成对应的默认成员函数。

五、继承与友元

⭕友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

在C++中，友元关系允许一个类或函数访问另一个类的私有成员或受保护成员。通过在类中声明其他类或函数为友元，可以授予这些友元类或函数对私有成员的访问权限。

然而，友元关系不会被继承。基类的友元关系仅适用于基类，不能自动扩展到派生类。这意味着基类的友元类不能直接访问派生类的私有或受保护成员。

让我们来看一个例子来说明这一点：

class Base {
private:
    int privateMember;
    
    friend class FriendClass; // 声明 FriendClass 为 Base 的友元类

public:
    void publicMemberFunc() {
        privateMember = 10; // 在类的成员函数中可以访问私有成员
    }
};

class Derived : public Base {
private:
    int derivedPrivateMember;
    
public:
    void derivedMemberFunc() {
        derivedPrivateMember = 20;
    }
};

class FriendClass {
public:
    void accessBaseMember(Base& obj) {
        obj.privateMember = 30; // 可以访问基类的私有成员
    }
};

int main() {
    Base baseObj;
    FriendClass friendObj;

    friendObj.accessBaseMember(baseObj); // 可以通过友元类访问基类的私有成员

    Derived derivedObj;

    friendObj.accessBaseMember(derivedObj); // 但不能通过友元类访问派生类的私有成员

    return 0;
}

在上面的例子中，FriendClass 被声明为 Base 的友元类，并且可以访问 Base 类的私有成员 privateMember。然而，FriendClass 无法访问派生类 Derived 的私有成员 derivedPrivateMember，即使 Derived 类是从 Base 类继承而来。

因此，友元关系不会在继承过程中自动传递。

总结来说，继承和友元是C++中的两个不同的概念。继承用于创建派生类从基类派生的关系，而友元用于授予其他类或函数对私有成员的访问权限。友元关系不会被继承，基类的友元类无法直接访问派生类的私有成员。

六、继承与静态成员

⭕基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例 。

静态成员由所有该类的对象共享，并在类的所有实例之间保持唯一。当在基类中定义一个静态成员时，在继承体系中的所有派生类中也只有一个实例。这意味着，无论有多少个派生类，静态成员只有一个实例。无论是访问、修改还是获取静态成员的值，都只会影响该唯一的实例。

以下示例说明了派生类继承了基类的静态成员的行为：

#include 

class Base {
public:
    static int staticMember;
};

int Base::staticMember = 0;

class Derived1 : public Base {
};

class Derived2 : public Base {
};

int main() {
    Derived1 d1;
    Derived2 d2;

    d1.staticMember = 10;
    d2.staticMember = 20;

    std::cout << d1.staticMember << std::endl; // 输出: 20
    std::cout << d2.staticMember << std::endl; // 输出: 20

    return 0;
}

在这个例子中，Base 类定义了一个静态成员 staticMember，默认为 0。Derived1 和 Derived2 是从 Base 派生出来的两个派生类。

d1.staticMember 和 d2.staticMember 都是访问相同的静态成员 Base::staticMember。修改其中一个派生类的静态成员的值，会同时影响到其他派生类和基类。

因此，无论有多少个派生类，都只有一个静态成员实例，它们共享相同的静态成员变量。这就是静态成员在继承体系中的行为。

七、复杂的菱形继承及菱形虚拟继承

⭕单继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

⭕多继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

⭕菱形继承

菱形继承是一种多重继承的情况，其中一个派生类同时从两个基类直接或间接继承，而这两个基类又继承自同一个基类。

这种继承关系可能导致一些问题，其中最常见的问题是称为"菱形继承问题"或"钻石继承问题"。它主要涉及两个方面：命名冲突和二义性。

1. 命名冲突问题

命名冲突问题指的是，如果派生类在两个基类中都有相同名称的成员，那么在派生类中访问该成员将会产生冲突。编译器无法判断使用哪个基类的成员，导致编译错误。

2. 二义性问题

二义性问题指的是，如果派生类调用一个在两个基类中都有定义的函数，编译器无法确定要调用哪个基类的函数，导致语义上的二义性。

3. 虚继承（virtual）

为了解决菱形继承问题，C++ 提供了虚继承（virtual inheritance）的机制，通过使用关键字 virtual 来声明基类继承，以便消除重复基类而带来的问题。虚继承确保在继承体系中只有一个共享的基类子对象。

下面是使用虚继承解决菱形继承问题的示例：

#include 

class Base {
public:
    int value;
};

class Derived1 : virtual public Base { // 使用虚继承
};

class Derived2 : virtual public Base { // 使用虚继承
};

class Derived3 : public Derived1, public Derived2 {
public:
    void setValue(int val) {
        value = val; // 可以直接访问 value，不会产生二义性
    }

    void printValue() {
        std::cout << value << std::endl; // 可以直接访问 value，不会产生二义性
    }
};

int main() {
    Derived3 d;
    d.setValue(10);
    d.printValue(); // 输出: 10

    return 0;
}

在上面的例子中，Derived1 和 Derived2 都使用了虚继承从 Base 继承。Derived3 从 Derived1 和 Derived2 多重继承，并可以直接访问共享的 value 成员，而不会产生二义性。

通过使用虚继承，我们可以解决菱形继承问题中的命名冲突和二义性。虚继承确保只有一个共享的基类子对象，避免了重复继承和二义性的问题。

需要注意的是，虚继承引入了额外的开销和复杂性，因此应谨慎使用。一般来说，只有在确实需要共享基类子对象的情况下才应使用虚继承。在其他情况下，使用普通的多重继承就可以满足需求。

八、继承的总结和反思

1. 很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
2. 多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承。

继承和组合

• public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
• 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
• 优先使用对象组合，而不是类继承（详细介绍链接）
• 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
• 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
• 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

九、笔试面试题

1. 什么是菱形继承？菱形继承的问题是什么？

【答】菱形继承是指在一个继承体系中，派生类同时从两个基类直接或间接继承，并且这两个基类又继承自同一个基类。由于继承关系形成了一个菱形的图形，因此得名菱形继承。菱形继承会带来一些问题，其中最常见的问题是命名冲突和二义性。

• 命名冲突：如果派生类 D 在两个基类 B 和 C 中都有相同名称的成员，那么在派生类 D 中访问该成员时会产生冲突。编译器无法确定要使用哪个基类的成员，导致编译错误。

• 二义性：如果派生类 D 调用一个在两个基类 B 和 C 中都有定义的函数时，编译器无法确定要调用哪个基类的函数，从而产生语义上的二义性。

为了解决菱形继承问题，C++ 提供了虚继承（virtual inheritance）的机制。通过在继承声明中使用 virtual 关键字，可以消除重复基类而带来的问题。虚继承确保在继承体系中只有一个共享的基类子对象，从而解决了命名冲突和二义性的问题。

2. 什么是菱形虚拟继承？如何解决数据冗余和二义性的？

【答】菱形虚拟继承是一种使用虚拟继承解决菱形继承问题的技术。它通过在继承声明中使用虚拟继承，消除了重复基类而带来的数据冗余和二义性问题。

菱形虚拟继承的主要目标是确保在继承体系中只有一个共享的基类子对象，从而避免数据冗余。通过虚拟继承，派生类只保留一个基类子对象的副本，而不是多个副本。

此外，菱形虚拟继承还解决了二义性问题。由于只有一个共享的基类子对象，派生类可以直接访问该对象的成员，而不会产生二义性。

通过菱形虚拟继承，我们可以解决菱形继承问题中的数据冗余和二义性。虚拟继承确保只有一个共享的基类子对象，从而避免了数据冗余。同时，派生类可以直接访问共享的基类成员，而不会产生二义性。

3. 继承和组合的区别？什么时候用继承？什么时候用组合？

【答】继承和组合是面向对象编程中两种不同的关系建立方式。

继承是一种"is-a"（是一个）的关系，它允许一个类（派生类）继承另一个类（基类）的属性和行为。通过继承，派生类可以重用基类的代码，并且可以添加、修改或覆盖基类的成员。继承用于表示类之间的一般化和特殊化关系，其中派生类是基类的一种特殊类型。

组合是一种"has-a"（有一个）的关系，它允许一个类（容器类）包含另一个类（成员类）的对象作为成员。通过组合，容器类可以使用成员类的功能，并且可以控制成员类的生命周期。组合用于表示类之间的整体与部分关系，其中容器类包含成员类作为其一部分。

1. 继承适合以下情况：

   • 当一个类是另一个类的特殊类型时，可以使用继承来表示它们之间的关系。
   • 当需要重用基类的代码，并在派生类中添加、修改或覆盖成员时，可以使用继承。
   • 当需要使用基类的指针或引用来操作派生类对象时，可以使用继承。

2. 组合适合以下情况：

   • 当一个类需要包含另一个类的对象作为其一部分时，可以使用组合来表示它们之间的关系。
   • 当需要控制成员对象的生命周期，并在容器对象的生命周期内创建、使用和销毁成员对象时，可以使用组合。
   • 当需要在容器对象中调用成员对象的功能时，可以使用组合。

继承和组合都是关系建立的方式，它们并不是互斥的。在实际的设计中，可以根据具体的需求和设计目标，灵活地使用继承和组合来构建类之间的关系。

温馨提示

感谢您对博主文章的关注与支持！另外，我计划在未来的更新中持续探讨与本文相关的内容，会为您带来更多关于C++以及编程技术问题的深入解析、应用案例和趣味玩法等。请继续关注博主的更新，不要错过任何精彩内容！

再次感谢您的支持和关注。期待与您建立更紧密的互动，共同探索C++、算法和编程的奥秘。祝您生活愉快，排便顺畅！