一、概述

C++中的多态性是指同一个函数可以有多种不同的实现方式，并且在运行时根据实际情况进行选择执行。在C++中实现多态有两种方式：静态多态和动态多态。静态多态是指在编译时确定函数的实现，包括函数重载和模板函数；动态多态是指在运行时根据对象的实际类型来确定函数的实现，包括虚函数和抽象类。

二、静态多态

1、函数重载

函数重载是指在同一个作用域中定义多个同名函数，它们的参数列表不同。编译器会根据函数的参数列表唯一地确定要调用的函数。函数重载的实现可以通过编译时的函数匹配来实现，实现起来比较简单。 下面是一个函数重载的示例代码：

#include <iostream>

void print(int i) {
    std::cout << "This is an integer: " << i << std::endl;
}

void print(float f) {
    std::cout << "This is a float: " << f << std::endl;
}

int main() {
    print(42);
    print(3.14f);
    return 0;
}

上面的代码中，我们定义了两个同名的函数`print`，但是它们的参数列表不同，一个接受整数，一个接受浮点数。在调用函数`print`时，编译器会自动根据参数的类型选择调用哪个函数。

2、模板函数

模板函数是指在定义函数时使用了类型参数，可以让函数适用于多种不同的类型。编译器会在编译时根据参数类型来生成具体的函数实现。模板函数的实现可以通过编译时的模板实例化来实现。 下面是一个模板函数的示例代码：

#include <iostream>
#include <cstdlib>

template <typename T>
T max(T a, T b) {
    return a > b ? a : b;
}

int main() {
    int x = 42, y = 23;
    float f = 3.14f, g = 2.71f;
    std::cout << "Max of " << x << " and " << y << " is " << max(x, y) << std::endl;
    std::cout << "Max of " << f << " and " << g << " is " << max(f, g) << std::endl;
    return 0;
}

上面的代码中，我们定义了一个模板函数`max`，它可以针对整数、浮点数等多种类型进行运算。在调用函数`max`时，编译器会根据参数类型自动推断出要使用哪个具体的函数实现。

三、动态多态

1、虚函数

虚函数是指在基类中定义的函数可以被派生类重写的函数。通过将函数声明为虚函数，我们可以在运行时根据对象的实际类型来确定要调用的函数实现。在C++中，只要将函数声明为虚函数即可实现动态多态。 下面是一个虚函数的示例代码：

#include <iostream>

class Shape {
public:
    virtual float calculateArea() { return 0; }
};

class Square : public Shape {
public:
    Square(float l) : _length(l) {}
    virtual float calculateArea() { return _length * _length; }
private:
    float _length;
};

class Circle : public Shape {
public:
    Circle(float r) : _radius(r) {}
    virtual float calculateArea() { return 3.14f * _radius * _radius; }
private:
    float _radius;
};

int main() {
    Shape *s1 = new Square(5);
    Shape *s2 = new Circle(3);
    std::cout << "Area of square is " << s1->calculateArea() << std::endl;
    std::cout << "Area of circle is " << s2->calculateArea() << std::endl;
    delete s1;
    delete s2;
    return 0;
}

上面的代码中，我们定义了一个基类`Shape`和两个派生类`Square`和`Circle`，它们都实现了函数`calculateArea`。在调用函数`calculateArea`时，我们将基类指针指向派生类对象，可以看到运行时实际调用的是派生类的实现函数。

2、抽象类

抽象类是指包含至少一个纯虚函数的类，这个类不能被实例化，只能用作基类来派生出其他类。在C++中，可以通过将函数声明为纯虚函数来实现抽象类。 下面是一个抽象类的示例代码：

#include <iostream>

class Shape {
public:
    virtual float calculateArea() = 0;
};

class Square : public Shape {
public:
    Square(float l) : _length(l) {}
    virtual float calculateArea() { return _length * _length; }
private:
    float _length;
};

class Circle : public Shape {
public:
    Circle(float r) : _radius(r) {}
    virtual float calculateArea() { return 3.14f * _radius * _radius; }
private:
    float _radius;
};

int main() {
    // Shape *s = new Shape();  // error: cannot instantiate abstract class
    Shape *s1 = new Square(5);
    Shape *s2 = new Circle(3);
    std::cout << "Area of square is " << s1->calculateArea() << std::endl;
    std::cout << "Area of circle is " << s2->calculateArea() << std::endl;
    delete s1;
    delete s2;
    return 0;
}

上面的代码中，我们将基类`Shape`中的函数`calculateArea`声明为纯虚函数，从而实现了抽象类。抽象类不能被实例化，只能用作基类来派生出其他类。在调用函数`calculateArea`时，我们将基类指针指向派生类对象，可以看到运行时实际调用的是派生类的实现函数。

四、总结

本文介绍了C++中实现运行时多态的两种方式：静态多态和动态多态。静态多态包括函数重载和模板函数，动态多态包括虚函数和抽象类。通过对这些知识点的学习，可以更好地理解C++中的多态性，更灵活地应用在实际的程序开发中。

本文链接：http://task.lmcjl.com/news/23.html