函数重载、运算符重载、虚函数、纯虚函数、抽象类

在C++中，多态性（Polymorphism）是面向对象编程的核心概念之一，允许同一接口调用不同的实现。C++中实现多态性的方式包括函数重载、运算符重载、虚函数、纯虚函数和抽象类。下面是对这些概念的详细解释和代码示例。

函数重载（Function Overloading）

函数重载是指在同一个作用域中定义多个具有相同名称但参数列表不同的函数。这些函数根据传递的参数进行区分。

示例代码：

#include <iostream>

class MyClass {
public:
    void display(int i) {
        std::cout << "Integer: " << i << std::endl;
    }
    
    void display(double d) {
        std::cout << "Double: " << d << std::endl;
    }
    
    void display(const std::string& str) {
        std::cout << "String: " << str << std::endl;
    }
};

int main() {
    MyClass obj;
    obj.display(42);          // 调用 display(int)
    obj.display(3.14);        // 调用 display(double)
    obj.display("Hello");     // 调用 display(const std::string&)
    return 0;
}

运算符重载（Operator Overloading）

运算符重载是指通过定义特殊的成员函数或友元函数来重定义C++中的运算符，使其适用于用户自定义类型。

示例代码：

#include <iostream>

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
    
    // 重载 + 运算符
    Complex operator + (const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
    
    void display() const {
        std::cout << "(" << real << ", " << imag << ")" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2; // 调用重载的 + 运算符
    c3.display();
    return 0;
}

虚函数（Virtual Functions）

虚函数是指在基类中使用关键字 virtual 声明的成员函数，允许在派生类中重写该函数，并通过基类指针或引用调用时，执行派生类的实现。

示例代码：

#include <iostream>

class Base {
public:
    virtual void display() {
        std::cout << "Base class display function." << std::endl;
    }
};

class Derived : public Base {
public:
    void display() override {
        std::cout << "Derived class display function." << std::endl;
    }
};

int main() {
    Base* b = new Derived(); // 基类指针指向派生类对象
    b->display();            // 调用派生类的 display 函数
    delete b;
    return 0;
}

纯虚函数（Pure Virtual Functions）

纯虚函数是指在基类中声明但不提供实现的虚函数，用 = 0 表示。含有纯虚函数的类是抽象类，不能实例化。

示例代码：

#include <iostream>

class AbstractBase {
public:
    virtual void display() = 0; // 纯虚函数
};

class ConcreteDerived : public AbstractBase {
public:
    void display() override {
        std::cout << "ConcreteDerived class display function." << std::endl;
    }
};

int main() {
    // AbstractBase ab; // 错误：不能实例化抽象类
    ConcreteDerived cd;
    cd.display();
    return 0;
}

抽象类（Abstract Class）

抽象类是包含至少一个纯虚函数的类。它不能实例化，只能作为基类被继承。

示例代码：

#include <iostream>

class AbstractBase {
public:
    virtual void display() = 0; // 纯虚函数
};

class ConcreteDerived : public AbstractBase {
public:
    void display() override {
        std::cout << "ConcreteDerived class display function." << std::endl;
    }
};

int main() {
    // AbstractBase ab; // 错误：不能实例化抽象类
    ConcreteDerived cd;
    AbstractBase* ab = &cd; // 基类指针指向派生类对象
    ab->display();          // 调用派生类的 display 函数
    return 0;
}

总结
函数重载：允许同名函数根据参数列表不同进行重载。
运算符重载：允许用户自定义类型重载C++运算符。
虚函数：基类中的虚函数允许派生类重写，并通过基类指针或引用调用时实现动态绑定。
纯虚函数：基类中声明但不实现的虚函数，派生类必须实现它。
抽象类：包含纯虚函数的类，不能实例化，只能被继承。
这些特性共同提供了强大的多态性机制，使得C++中的面向对象编程更为灵活和高效。