当前位置：首页 > article >正文

C++多态性

article 2025/1/31 23:41:19

概念

C++中的多态性是面向对象编程的一个重要特征，它允许我们通过一个基类的指针或引用来操作不同派生类的对象。多态性增强了代码的灵活性和可扩展性。主要分为两种类型：编译时多态（静态多态）和运行时多态（动态多态）。

编译时多态（静态多态）

编译时多态通常通过函数重载和运算符重载实现。编译器在编译时决定调用哪个函数。

#include <iostream>  
using namespace std;  

class Print {  
public:  
    void display(int i) {  
        cout << "Displaying integer: " << i << endl;  
    }  
    void display(double d) {  
        cout << "Displaying double: " << d << endl;  
    }  
};  

int main() {  
    Print p;  
    p.display(5);     // 调用display(int)  
    p.display(5.5);   // 调用display(double)  
    return 0;  
}

运行时多态（动态多态）

运行时多态通过虚函数实现，允许在运行时根据对象的实际类型调用相应的函数。当我们定义一个虚函数并在子类中重写它时，基类的指针或引用可以指向子类的对象，并根据实际对象的类型调用相应的函数。

#include <iostream>  
using namespace std;  

class Base {  
public:  
    virtual void show() { // 虚函数  
        cout << "Base class show function called." << endl;  
    }  
    virtual ~Base() {} // 虚析构函数  
};  

class Derived : public Base {  
public:  
    void show() override { // 重写虚函数  
        cout << "Derived class show function called." << endl;  
    }  
};  

int main() {  
    Base* basePtr;          // 基类指针  
    Derived derivedObj;     // 派生类对象  
    basePtr = &derivedObj;  // 指向派生类对象  
    basePtr->show();        // 调用派生类的show()  
    
    return 0;  
}

原理

1.虚函数
虚函数是在基类中使用virtual关键字声明的函数，用于支持运行时多态。通过虚函数，可以在基类中定义接口，而在派生类中实现具体的逻辑。当使用基类指针或引用指向派生类对象并调用该虚函数时，C++会根据对象的真实类型来调用相应的函数实现。

2. 虚表（vtable）
每个包含虚函数的类在运行时会有一个虚表（vtable）。这个虚表是一个函数指针数组，存储了该类的所有虚函数的地址。当创建一个对象时，编译器会为该对象生成一个指向其类虚表的指针，称为虚指针（vptr）。

3. 运行时过程
运行时多态的过程大致如下：

1.声明和定义：在基类中用virtual关键字声明虚函数，在派生类中重写该虚函数。
2.对象创建：当基类指针或引用指向派生类对象时，派生类对象的虚指针会指向派生类的虚表。

3.函数调用：

当通过基类指针或引用调用虚函数时，程序会查找对象的虚表，找到对应虚函数的地址并执行。这是一个动态过程，因为决定调用哪个函数是在运行时而不是编译时。

#include <iostream>  
using namespace std;  

class Base {  
public:  
    virtual void show() {  // 虚函数  
        cout << "Base class show function called." << endl;  
    }  
    virtual ~Base() {}  // 虚析构函数  
};  

class Derived : public Base {  
public:  
    void show() override {  // 重写虚函数  
        cout << "Derived class show function called." << endl;  
    }  
};  

void demonstratePolymorphism(Base* b) {  
    b->show();  // 调用虚函数  
}  

int main() {  
    Base baseObj;        // 基类对象  
    Derived derivedObj;  // 派生类对象  

    demonstratePolymorphism(&baseObj);       // 调用基类的 show  
    demonstratePolymorphism(&derivedObj);    // 调用派生类的 show  
    
    return 0;  
}

创建基类Base和派生类Derived，Derived重写了Base中的虚函数show。
函数demonstratePolymorphism接受基类指针作为参数，调用show函数。实际上，将根据指针所指向的对象类型来调用相应的版本。
当调用show时，即使传入的是基类指针，实际执行的是派生类的show。

重载，重写，隐藏

重载（Overloading）

重载是指在同一作用域内可以定义多个同名函数，只要它们的参数列表（参数的数量或类型）不同就可以。重载发生在同一个类中，也可以在继承关系中的不同类中的同名函数。

#include <iostream>  
using namespace std;  

class Math {  
public:  
    // 重载：不同参数数量和类型  
    int add(int a, int b) {  
        return a + b;  
    }  

    double add(double a, double b) {  
        return a + b;  
    }  
    
    int add(int a, int b, int c) {  
        return a + b + c;  
    }  
};  

int main() {  
    Math math;  
    cout << math.add(1, 2) << endl;        // 调用 add(int, int)  
    cout << math.add(1.5, 2.5) << endl;    // 调用 add(double, double)  
    cout << math.add(1, 2, 3) << endl;     // 调用 add(int, int, int)  
    
    return 0;  
}

在上面的例子中，add函数被重载，具有不同的参数类型和数量。

重写（Overriding）

重写是指在派生类中重新定义基类中已经声明的虚函数。重写允许派生类为基类的虚函数提供特定的实现。重写是在继承关系中发生的，它通常涉及到基类的虚函数和派生类的同名函数。

#include <iostream>  
using namespace std;  

class Base {  
public:  
    virtual void show() {  // 虚函数允许重写  
        cout << "Base class show function." << endl;  
    }  
};  

class Derived : public Base {  
public:  
    void show() override {  // 重写基类的虚函数  
        cout << "Derived class show function." << endl;  
    }  
};  

int main() {  
    Base* basePtr;  
    Derived derived;  
    basePtr = &derived;  
    
    basePtr->show();  // 调用 Derived::show()  
    
    return 0;  
}

在这段代码中，Derived类中的show函数重写了Base类中的虚函数show。通过基类指针调用时，会执行派生类的实现。

隐藏（Hiding）

隐藏是指在派生类中定义一个与基类中同名的成员（可以是函数或变量），这会遮蔽基类中的所有同名成员。隐藏不是重载，也不是重写，它发生在同一作用域内，并且会隐藏基类中的所有同名函数和变量，不论其参数和返回类型。

#include <iostream>  
using namespace std;  

class Base {  
public:  
    void func(int i) {  
        cout << "Base func with int: " << i << endl;  
    }  
    
    void func(double d) {  
        cout << "Base func with double: " << d << endl;  
    }  
};  

class Derived : public Base {  
public:  
    void func(int i) {  // 该函数隐藏了 Base 中的所有 named func  
        cout << "Derived func with int: " << i << endl;  
    }  
};  

int main() {  
    Derived d;  
    d.func(10);         // 调用 Derived::func(int)  
    // d.func(3.14);    // 错误：Base::func(double) 被隐藏，不能调用  
    
    return 0;  
}