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

慕卿扬

已于 2024-08-25 01:50:16 修改

阅读量718

点赞数 29

分类专栏： C++语言学习文章标签： c++ 学习方法笔记

于 2024-08-25 01:49:33 首次发布

本文链接：https://blog.csdn.net/qq_74375828/article/details/141477908

版权

C++语言学习专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、多继承

在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: 10

    Shape* shape2 = new Rectangle();
    shape2->draw(); // 输出：Drawing a rectangle.
    shape2->draw(20); // 输出：Drawing a shape with width: 20

    delete 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对象。

注意：

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

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++中，赋值兼容规则分为以下两种情况：

基本数据类型的赋值兼容规则：
- 相同类型的变量可以直接赋值给对应类型的变量。
- 较小类型的变量可以赋值给较大类型的变量，这种情况下会自动进行类型转换，不会丢失数据。
- 浮点数可以赋值给整数类型，但会发生截断。
例如：
```
int a = 10;
double b = 3.14;
a = b;  // 自动进行类型转换，b的值3.14会被截断为整数3，赋值给a。
```
类类型的赋值兼容规则：
- 类类型之间的赋值必须通过拷贝构造函数或者赋值运算符来完成。
- 如果类定义了拷贝构造函数或者赋值运算符，那么可以将一个对象赋值给另一个对象，这会调用拷贝构造函数或者赋值运算符进行对象间的成员变量的赋值操作。
- 如果没有定义拷贝构造函数或者赋值运算符，则无法直接进行对象之间的赋值操作。
例如：
```
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++中实现多态性的关键机制，它们允许基类定义接口并要求派生类实现，从而实现了程序的灵活性和可扩展性。