c++多态小结

小咪咪 2024-03-22 11:24 57阅读 0赞

**目录**

1. 基类中的虚函数必须以 virtual 关键字开头

2. 子类中的虚函数必须与基类中的虚函数具有相同的函数名

3. 子类中的虚函数必须使用 override 关键字标记

4. 调用虚函数时，实际上调用的是对象的类型所对应的函数

5. 可以将子类对象赋值给基类指针或引用

6. 析构函数必须是虚函数

7. 虚函数可以被纯虚函数替代

在 C++ 中使用多态时，需要注意的几个细节包括：

--------------------

### 1. 基类中的虚函数必须以 virtual 关键字开头 ###

在 C++ 中，要实现多态，必须将基类中的成员函数声明为虚函数。因此，在基类中声明虚函数时，必须在函数签名前加上 virtual 关键字，如下所示：

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

### 2. 子类中的虚函数必须与基类中的虚函数具有相同的函数名 ###

在子类中重写基类中的虚函数时，必须保证函数名与基类中的虚函数完全相同。否则，编译器将无法识别它们是同一个函数，无法实现多态。例如：

class Dog : public Animal {
    public:
        void eat(int food) { // 错误的重载，参数不同
            cout << "Dog is eating " << food << "." << endl;
        }
    };

这里的 eat() 函数与基类中的 eat() 函数的参数不同，因此编译器无法识别它们是同一个函数，也就无法实现多态。

### 3. 子类中的虚函数必须使用 override 关键字标记 ###

在子类中重写基类中的虚函数时，必须使用 override 关键字标记，以确保它们是重写而不是重载。例如：

class Dog : public Animal {
    public:
        void eat() override { // 使用 override 关键字标记
            cout << "Dog is eating meat." << endl;
        }
    };

这里我们在 eat() 函数前使用了 override 关键字标记，这可以帮助编译器检测我们是否正确地重写了基类中的虚函数。

### 4. 调用虚函数时，实际上调用的是对象的类型所对应的函数 ###

在使用多态时，程序会根据对象的实际类型来选择调用相应的函数。例如：

Animal* animal = new Dog();
    animal->eat(); // 输出 "Dog is eating meat."

在这里，我们创建了一个指向 Dog 对象的 Animal 指针，然后调用了它的 eat() 函数。由于 eat() 函数是虚函数，程序会根据对象的实际类型（即 Dog 类型）来选择调用相应的函数，输出 "Dog is eating meat." 的信息。

### 5. 可以将子类对象赋值给基类指针或引用 ###

在使用多态时，可以将子类对象赋值给基类指针或引用，从而实现对子类对象的访问。例如：

Dog dog;
    Animal& animal = dog; // 使用引用
    Animal* animalPtr = &dog; // 使用指针

在这里，我们创建了一个 Dog 对象和一个 Animal 引用，将 Dog 对象赋值

给 Animal 引用，然后将这个引用用于调用 eat() 函数。由于 eat() 函数是虚函数，程序会根据对象的实际类型（即 Dog 类型）来选择调用相应的函数，输出 "Dog is eating meat." 的信息。

### 6. 析构函数必须是虚函数 ###

在使用多态时，必须将基类的析构函数声明为虚函数，以确保正确地释放子类对象的内存空间。例如：

class Animal {
    public:
        virtual ~Animal() {
            cout << "Animal destructor called." << endl;
        }
    };
    
    class Dog : public Animal {
    public:
        ~Dog() {
            cout << "Dog destructor called." << endl;
        }
    };

在这里，我们将基类 Animal 的析构函数声明为虚函数，并在子类 Dog 中实现了自己的析构函数。由于基类析构函数是虚函数，当我们使用 delete 删除指向子类对象的基类指针时，程序会调用子类的析构函数来正确释放内存空间。

### 7. 虚函数可以被纯虚函数替代 ###

在使用多态时，还可以将虚函数替换为纯虚函数，以达到强制子类实现该函数的目的。例如：

class Animal {
    public:
        virtual void eat() = 0; // 声明为纯虚函数
    };
    
    class Dog : public Animal {
    public:
        void eat() override {
            cout << "Dog is eating meat." << endl;
        }
    };

在这里，我们将 eat() 函数声明为纯虚函数，这意味着基类中不再提供实现。由于子类必须实现纯虚函数才能被实例化，因此我们在 Dog 类中实现了 eat() 函数。

## 在 C++ 中使用多态时，需要注意的几个细节包括： ##

1. 基类中的虚函数必须以 virtual 关键字开头。  
2. 子类中的虚函数必须与基类中的虚函数具有相同的函数名。  
3. 子类中的虚函数必须使用 override 关键字标记。  
4. 调用虚函数时，实际上调用的是对象的类型所对应的函数。  
5. 可以将子类对象赋值给基类指针或引用。  
6. 析构函数必须是虚函数。  
7. 虚函数可以被纯虚函数替代，以达到强制子类实现该函数的目的。