C++语言学习（八）—— 继承、派生与多态（二）

2024-08-25 07:12
文章标签 语言 c++ 学习 继承 多态 派生

本文主要是介绍C++语言学习（八）—— 继承、派生与多态（二），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

目录

一、多继承

1.1 多继承中的二义性问题

1.2 虚基类

二、多态

2.1 静态绑定与静态多态

2.2 动态绑定与动态多态

三、运算符重载

3.1 重载++、- -运算符

3.2 重载赋值运算符

3.3 重载输出流<<、输入流>>运算符

3.3.1 重载输出流（<<）运算符

3.3.2 重载输入流（>>）运算符

四、赋值兼容规则

五、虚函数

5.1 虚函数的定义

5.2 虚析构函数

5.3 纯虚函数及抽象类

一、多继承

在C++中，多继承是一种面向对象的编程技术，允许一个类从多个父类派生而来，继承多个父类的属性和方法。

在C++中，可以使用逗号分隔的方式来指定多个父类。语法如下：

class DerivedClass : public BaseClass1, public BaseClass2, ... {// 类的定义
};

在多继承中，派生类继承了所有父类的成员，包括数据成员和成员函数。如果多个父类中有同名的成员，派生类需要通过作用域限定符来指定使用哪个父类的成员。

多继承为程序带来了灵活性和代码复用的好处，但也需要小心处理一些问题，比如菱形继承问题。菱形继承是指派生类同时从两个父类继承某个公共的父类，可能导致代码复杂性和二义性问题。在C++中，可以使用虚继承来解决菱形继承的问题。

1.1 多继承中的二义性问题

多继承中的二义性问题是指在派生类中存在两个或多个父类，这些父类拥有同名的成员（包括成员函数和数据成员），从而导致在派生类中无法判断要使用哪个父类的成员。

当多个父类拥有同名成员时，如果派生类直接访问同名成员，会导致编译错误，编译器无法确定要使用哪个父类的成员。 这种情况下，需要在派生类中通过作用域限定符来明确指定使用哪个父类的成员。例如：

// BaseClass1 和 BaseClass2 都有同名的成员函数 foo()
class DerivedClass : public BaseClass1, public BaseClass2 {public:void callFoo() {// 使用作用域限定符来指定使用哪个父类的成员函数BaseClass1::foo();}
};

另一种避免二义性问题的方法是使用虚继承。虚继承是指通过使用关键字virtual在基类之间建立虚继承关系，这样可以确保只有一份共享的基类子对象。例如：

class BaseClass {// 类定义
};// 使用虚继承
class DerivedClass1 : virtual public BaseClass {// 类定义
};// 使用虚继承
class DerivedClass2 : virtual public BaseClass {// 类定义
};// 派生类同时从 DerivedClass1 和 DerivedClass2 继承
class DerivedClass3 : public DerivedClass1, public DerivedClass2 {// 类定义
};

在使用虚继承时，由于只有一份共享的基类子对象，因此二义性问题会被解决。

1.2 虚基类

虚基类是在C++中使用虚继承（virtual inheritance）实现的。虚基类解决了多继承中的二义性问题。

当一个派生类从多个基类继承时，如果这些基类中有一个公共基类作为虚基类，那么虚基类将被派生类共享。这意味着虚基类在派生类中只会有一份实例，避免了二义性问题。

虚继承的语法是通过在派生类的继承列表中使用关键字virtual来声明虚继承。例如：

class BaseClass {// 类定义
};// 虚继承
class DerivedClass : virtual public BaseClass {// 类定义
};

当派生类通过虚继承从多个基类继承时，如果这些基类中有一个公共基类，那么这个公共基类将在派生类中只有一份实例。这样，在派生类中访问公共基类的成员时就不会产生二义性。

二、多态

C++中的多态是面向对象编程的一个重要概念，它允许使用基类的指针或引用来调用派生类的方法，实现了动态绑定（dynamic binding）。

多态性在面向对象编程中非常有用，它允许以一种通用的方式操作不同类型的对象，提高了代码的可扩展性和可维护性。

2.1 静态绑定与静态多态

在C++中，静态绑定（static binding）是指在编译时确定函数调用的具体实现；而静态多态（static polymorphism）是指在编译时根据函数的参数类型来选择合适的函数实现。

静态绑定是指在编译时，根据调用对象的静态类型确定调用的函数。也就是说，在编译时，编译器会根据指针或引用的静态类型来确定调用的函数，而不会考虑指针或引用所指向的对象的实际类型。

静态多态是指通过函数重载实现的多态。在C++中，函数重载允许定义多个同名函数，但它们的参数列表必须不同。在编译时，根据调用对象的静态类型和函数的参数列表来确定调用的函数。

下面是一个简单的示例，展示了静态绑定和静态多态的使用：

class Shape {
public:void draw() {cout << "Drawing a shape." << endl;}void draw(int width) {cout << "Drawing a shape with width: " << width << endl;}
};class Rectangle : public Shape {
public:void draw() {cout << "Drawing a rectangle." << endl;}
};int main() {Shape* shape1 = new Shape();shape1->draw(); // 输出：Drawing a shape.shape1->draw(10); // 输出：Drawing a shape with width: 10Shape* shape2 = new Rectangle();shape2->draw(); // 输出：Drawing a rectangle.shape2->draw(20); // 输出：Drawing a shape with width: 20delete shape1;delete shape2;return 0;
}

在上面的示例中，Shape类中定义了两个重载的draw()函数，一个是不带参数的，一个是带一个int类型参数的。Rectangle类继承自Shape类，并重写了draw()函数。

在main()函数中，通过Shape指针shape1来调用draw()函数，编译器根据shape1的类型为Shape，所以会调用Shape类中定义的draw()函数。

而通过Shape指针shape2来调用draw()函数时，编译器根据shape2的类型为Shape，但实际指向的对象是Rectangle类的对象，所以会调用Rectangle类中重写的draw()函数。同样，根据shape2的类型和函数参数列表，调用的是Shape类中定义的带一个int类型参数的draw()函数。

2.2 动态绑定与动态多态

在C++中，动态绑定（dynamic binding）是指在运行时根据对象的实际类型来确定函数调用的具体实现；动态多态（dynamic polymorphism）是指通过运行时多态性实现的多态特性。

动态绑定是指通过使用虚函数实现的动态多态性。当使用基类的指针或引用来调用一个虚函数时，编译器会在运行时根据实际对象的类型来确定调用的函数。这就意味着，虚函数的具体实现是在运行时动态绑定的，而不是在编译时静态绑定的。

动态多态是指通过继承和虚函数实现的多态性。在C++中，可以将一个函数声明为虚函数，使用virtual关键字来标识。派生类可以覆盖基类的虚函数，实现自己的特定行为。在运行时，如果通过基类的指针或引用调用虚函数，实际执行的是对象的实际类型对应的函数。

下面是一个简单的示例，展示了动态绑定和动态多态的使用：

class Shape {
public:virtual void draw() {cout << "Drawing a shape." << endl;}
};class Rectangle : public Shape {
public:void draw() {cout << "Drawing a rectangle." << endl;}
};int main() {Shape* shape1 = new Shape();shape1->draw(); // 输出：Drawing a shape.Shape* shape2 = new Rectangle();shape2->draw(); // 输出：Drawing a rectangle.delete shape1;delete shape2;return 0;
}

在上面的示例中，Shape类中的draw()函数被声明为虚函数。Rectangle类继承自Shape类，并重写了draw()函数。

在main()函数中，通过Shape指针shape1来调用draw()函数。由于draw()函数是虚函数，在运行时会根据shape1指向的对象的实际类型来确定调用的函数，因此会调用Shape类中定义的draw()函数。

通过Shape指针shape2来调用draw()函数时，它指向的对象是Rectangle类的对象，所以在运行时会调用Rectangle类中重写的draw()函数。

三、运算符重载

运算符重载：是指在编程语言中，为自定义的类类型或用户自定义的数据类型添加一些额外的操作符和功能。通过重载操作符，可以使得自定义的类类型对象能够像内置类型一样使用操作符进行相应的操作。

在C++中，运算符可以使用关键字operator来重载，例如：

class MyClass {
public:int value;MyClass(int val) : value(val) {}MyClass operator+(const MyClass& other) const {return MyClass(value + other.value);}
};

在上面的例子中，我们重载了加法运算符+，使得两个MyClass对象可以进行相加操作并返回一个新的MyClass对象。

注意：

  1. 运算符只能重载已有的运算符，不能创建新的运算符；
  2. 运算符重载的函数必须是成员函数或友元函数；
  3. 运算符重载函数的参数个数和类型应该与原始运算符相匹配；
  4. 运算符重载函数一般需要返回一个新的对象，而不是修改原始对象。

3.1 重载++、- -运算符

重载++和--运算符是常见的运算符重载操作之一，用于实现对象的自增和自减操作。

在C++中，++和--运算符可以分为前置运算和后置运算两种形式。前置运算符表示在变量之前进行自增或自减操作，后置运算符表示在变量之后进行自增或自减操作。

下面是对++和--运算符的重载示例：

class MyClass {
public:int value;MyClass(int val) : value(val) {}// 前置自增运算符重载MyClass& operator++() {++value;return *this;}// 前置自减运算符重载MyClass& operator--() {--value;return *this;}// 后置自增运算符重载MyClass operator++(int) {MyClass copy(*this);++value;return copy;}// 后置自减运算符重载MyClass operator--(int) {MyClass copy(*this);--value;return copy;}
};

在上面的示例中，我们重载了前置和后置的自增和自减运算符。对于前置运算符，我们直接对value进行自增和自减操作，并返回修改后的对象自身的引用。对于后置运算符，我们先创建一个当前对象的副本，然后对value进行自增和自减操作，并返回这个副本。

使用示例：

MyClass obj(10);
++obj;     // 前置自增
obj++;     // 后置自增--obj;     // 前置自减
obj--;     // 后置自减

3.2 重载赋值运算符

重载赋值运算符（=）是一种特殊的运算符重载，用于在对象间进行赋值操作。通过重载赋值运算符，我们可以自定义对象之间的赋值行为。

在C++中，赋值运算符的重载函数以特殊的成员函数形式存在，其名称为operator=。它接受一个参数，这个参数表示要赋值给对象的值。

下面是一个重载赋值运算符的示例：

class MyClass {
public:int value;MyClass(int val) : value(val) {}// 赋值运算符重载MyClass& operator=(const MyClass& other) {value = other.value;return *this;}
};

在上面的示例中，我们重载了赋值运算符，参数为类型为const MyClass&的other对象。我们将other对象的value成员赋值给当前对象的value成员，并返回当前对象的引用。

使用示例：

MyClass obj1(10);
MyClass obj2(20);obj1 = obj2;   // 使用赋值运算符将obj2的值赋给obj1

3.3 重载输出流<<、输入流>>运算符

重载输出流（<<）和输入流（>>)运算符是一种重载C++标准库中的流插入（output）和流提取（input）操作符，使得我们可以以自定义的方式向流中输出数据或者从流中提取数据。

3.3.1 重载输出流（<<）运算符

重载输出流运算符（<<）的函数通常被定义为友元函数，它以两个参数的形式存在，第一个参数是ostream类型的输出流对象，第二个参数是要输出的自定义类型的对象。函数体中实现了将自定义类型的对象输出到流中的逻辑。函数的返回值通常是ostream对象的引用，以便连续输出。

下面是一个重载输出流运算符的示例：

class MyData {
public:int value1;int value2;MyData(int val1, int val2) : value1(val1), value2(val2) {}// 输出流运算符重载friend std::ostream& operator<<(std::ostream& os, const MyData& data) {os << "Value 1: " << data.value1 << ", Value 2: " << data.value2;return os;}
};

在上面的示例中，我们重载了输出流运算符，将MyData对象的成员变量值输出到流中，并返回输出流对象的引用。

使用示例：

MyData data(10, 20);
std::cout << data << std::endl;   // 使用重载的输出流运算符将data对象的值输出到控制台

3.3.2 重载输入流（>>）运算符

重载输入流运算符（>>)的函数也通常被定义为友元函数，它以两个参数的形式存在，第一个参数是istream类型的输入流对象，第二个参数是要输出的自定义类型的对象的引用。函数体中实现了从流中提取数据并赋值给自定义类型的对象的逻辑。

下面是一个重载输入流运算符的示例：

class MyData {
public:int value1;int value2;// 输入流运算符重载friend std::istream& operator>>(std::istream& is, MyData& data) {is >> data.value1 >> data.value2;return is;}
};

使用示例：

MyData data;
std::cin >> data;   // 使用重载的输入流运算符从控制台输入数据并赋值给data对象

四、赋值兼容规则

赋值兼容规则是指在进行赋值操作时，要求赋值号两边的操作数类型能够相互转换，并且满足特定的规则。

在C++中，赋值兼容规则分为以下两种情况：

  1. 基本数据类型的赋值兼容规则：

    • 相同类型的变量可以直接赋值给对应类型的变量。
    • 较小类型的变量可以赋值给较大类型的变量，这种情况下会自动进行类型转换，不会丢失数据。
    • 浮点数可以赋值给整数类型，但会发生截断。

    例如：

    int a = 10;
double b = 3.14;
a = b;  // 自动进行类型转换，b的值3.14会被截断为整数3，赋值给a。

  2. 类类型的赋值兼容规则：

    • 类类型之间的赋值必须通过拷贝构造函数或者赋值运算符来完成。
    • 如果类定义了拷贝构造函数或者赋值运算符，那么可以将一个对象赋值给另一个对象，这会调用拷贝构造函数或者赋值运算符进行对象间的成员变量的赋值操作。
    • 如果没有定义拷贝构造函数或者赋值运算符，则无法直接进行对象之间的赋值操作。

    例如：

    class MyClass {
public:int value;MyClass(int val) : value(val) {}
};MyClass obj1(10);
MyClass obj2 = obj1;  // 调用拷贝构造函数，将obj1的value赋值给obj2的value。

五、虚函数

5.1 虚函数的定义

C++中的虚函数是一种特殊的成员函数，它允许在派生类中重写基类的同名函数。通过使用虚函数，可以实现多态性，即在运行时根据对象的实际类型调用相应的函数。

要将成员函数声明为虚函数，只需要在基类中将函数声明为虚函数，使用关键字"virtual"即可。例如：

class Base {
public:virtual void print() {cout << "This is Base class." << endl;}
};class Derived : public Base {
public:void print() override {cout << "This is Derived class." << endl;}
};

在上面的例子中，print()函数被声明为虚函数。在派生类Derived中，通过重写print()函数，可以实现不同的行为。当使用基类指针或引用调用print()函数时，会根据对象的实际类型来确定调用函数。

虚函数在派生类中可以被重写，也可以在派生类中使用override关键字来标记重写，以增强代码的可读性。同时，可以使用virtual关键字来显式地标记派生类中的虚函数（非必需）。

虚函数是多态性的基础，在使用多态性时，通常会通过基类指针或引用来操作派生类对象。例如：

Base* b = new Derived();
b->print(); // 调用Derived类的print()函数

在上面的代码中，使用基类指针b指向派生类对象Derived，并调用print()函数。由于print()函数被声明为虚函数，因此会根据对象的实际类型调用Derived类的版本。

5.2 虚析构函数

C++中的虚析构函数用于实现基类和派生类之间的多态析构，以确保在删除派生类对象时，能正确调用派生类和基类的析构函数。

在C++中，如果一个类拥有虚函数，那么最好将其析构函数也声明为虚函数。当使用基类指针删除一个派生类对象时，如果基类的析构函数不是虚函数，只会调用基类的析构函数，而不会调用派生类的析构函数。这可能导致派生类中的资源没有被正确释放，造成内存泄漏。

以下是一个使用虚析构函数的示例：

class Base {
public:virtual ~Base() {cout << "Base destructor" << endl;}
};class Derived : public Base {
public:~Derived() override {cout << "Derived destructor" << endl;}
};int main() {Base* basePtr = new Derived();delete basePtr;return 0;
}

在上面的例子中，Base类的析构函数被声明为虚函数，Derived类继承自Base类并重写了析构函数。在main函数中，我们创建了一个Derived类对象的指针，并将其赋值给Base类指针。当我们使用delete删除basePtr时，会触发析构函数的调用。由于Base类的析构函数是虚函数，因此会先调用Derived类的析构函数，再调用Base类的析构函数。

输出结果：

Derived destructor
Base destructor

5.3 纯虚函数及抽象类

纯虚函数是在基类中通过在函数声明前加上关键字"virtual"并在函数后面加上"= 0"来声明的一种特殊的虚函数。纯虚函数没有函数体，其目的是为了在基类中只定义接口而不实现具体的功能。

抽象类是包含至少一个纯虚函数的类，它不能被实例化，只能作为基类来派生新的类。抽象类的主要目的是提供一种接口或者规范，它定义了派生类必须实现的纯虚函数。

纯虚函数和抽象类常常一起使用，通过在基类中声明纯虚函数，可以强制派生类实现这些函数，从而实现多态性。派生类需要实现基类中的纯虚函数才能被编译通过。

以下是一个简单的示例代码：

class Animal {
public:virtual void sound() const = 0; // 纯虚函数
};class Cat : public Animal {
public:void sound() const override {cout << "喵喵喵" << endl;}
};class Dog : public Animal {
public:void sound() const override {cout << "汪汪汪" << endl;}
};int main() {Animal* animPtr = new Cat();animPtr->sound(); // 输出: 喵喵喵animPtr = new Dog();animPtr->sound(); // 输出: 汪汪汪delete animPtr;return 0;
}

在上述示例中，Animal类是一个抽象类，其sound()函数被声明为纯虚函数，因此Animal类不能被实例化。通过派生类Cat和Dog分别实现了sound()函数，使它们成为了具体的类。在main函数中，使用Animal指针指向不同的派生类对象，调用sound()函数实现了多态性。

纯虚函数和抽象类是C++中实现多态性的关键机制，它们允许基类定义接口并要求派生类实现，从而实现了程序的灵活性和可扩展性。

这篇关于C++语言学习（八）—— 继承、派生与多态（二）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1104894。

相关文章

C++ 中的 if-constexpr语法和作用

C++ 中的 if-constexpr语法和作用

《C++中的if-constexpr语法和作用》if-constexpr语法是C++17引入的新语法特性,也被称为常量if表达式或静态if（staticif）,：本文主要介绍C++中的if-c... 目录1 if-constexpr 语法1.1 基本语法1.2 扩展说明1.2.1 条件表达式1.2.2 fa
阅读更多...
C语言中的数据类型强制转换

C语言中的数据类型强制转换

《C语言中的数据类型强制转换》：本文主要介绍C语言中的数据类型强制转换方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录C语言数据类型强制转换自动转换强制转换类型总结C语言数据类型强制转换强制类型转换：是通过类型转换运算来实现的，主要的数据类型转换分为自动转换
阅读更多...
利用Go语言开发文件操作工具轻松处理所有文件

利用Go语言开发文件操作工具轻松处理所有文件

《利用Go语言开发文件操作工具轻松处理所有文件》在后端开发中,文件操作是一个非常常见但又容易出错的场景,本文小编要向大家介绍一个强大的Go语言文件操作工具库,它能帮你轻松处理各种文件操作场景... 目录为什么需要这个工具？核心功能详解1. 文件/目录存javascript在性检查2. 批量创建目录3. 文件
阅读更多...
C语言实现两个变量值交换的三种方式

C语言实现两个变量值交换的三种方式

《C语言实现两个变量值交换的三种方式》两个变量值的交换是编程中最常见的问题之一,以下将介绍三种变量的交换方式,其中第一种方式是最常用也是最实用的,后两种方式一般只在特殊限制下使用,需要的朋友可以参考下... 目录1.使用临时变量（推荐）2.相加和相减的方式（值较大时可能丢失数据）3.按位异或运算1.使用临时
阅读更多...
使用C语言实现交换整数的奇数位和偶数位

使用C语言实现交换整数的奇数位和偶数位

《使用C语言实现交换整数的奇数位和偶数位》在C语言中,要交换一个整数的二进制位中的奇数位和偶数位,重点需要理解位操作,当我们谈论二进制位的奇数位和偶数位时,我们是指从右到左数的位置,本文给大家介绍了使... 目录一、问题描述二、解决思路三、函数实现四、宏实现五、总结一、问题描述使用C语言代码实现：将一个整
阅读更多...
C++中::SHCreateDirectoryEx函数使用方法

C++中::SHCreateDirectoryEx函数使用方法

《C++中::SHCreateDirectoryEx函数使用方法》::SHCreateDirectoryEx用于创建多级目录,类似于mkdir-p命令,本文主要介绍了C++中::SHCreateDir... 目录1. 函数原型与依赖项2. 基本使用示例示例 1：创建单层目录示例 2：创建多级目录3. 关键注
阅读更多...
C++从序列容器中删除元素的四种方法

C++从序列容器中删除元素的四种方法

《C++从序列容器中删除元素的四种方法》删除元素的方法在序列容器和关联容器之间是非常不同的,在序列容器中,vector和string是最常用的,但这里也会介绍deque和list以供全面了解,尽管在一... 目录一、简介二、移除给定位置的元素三、移除与某个值相等的元素3.1、序列容器vector、deque
阅读更多...
C++常见容器获取头元素的方法大全

C++常见容器获取头元素的方法大全

《C++常见容器获取头元素的方法大全》在C++编程中,容器是存储和管理数据集合的重要工具,不同的容器提供了不同的接口来访问和操作其中的元素,获取容器的头元素（即第一个元素）是常见的操作之一,本文将详细... 目录一、std::vector二、std::list三、std::deque四、std::forwa
阅读更多...
C++字符串提取和分割的多种方法

C++字符串提取和分割的多种方法

《C++字符串提取和分割的多种方法》在C++编程中,字符串处理是一个常见的任务,尤其是在需要从字符串中提取特定数据时,本文将详细探讨如何使用C++标准库中的工具来提取和分割字符串,并分析不同方法的适用... 目录1. 字符串提取的基本方法1.1 使用 std::istringstream 和 >> 操作符示
阅读更多...
C++原地删除有序数组重复项的N种方法

C++原地删除有序数组重复项的N种方法

《C++原地删除有序数组重复项的N种方法》给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素只出现一次,返回移除后数组的新长度,不要使用额外的数组空间,你必须在原地修改输入数组并在使用O(... 目录一、问题二、问题分析三、算法实现四、问题变体：最多保留两次五、分析和代码实现5.1、问题分析5.
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2