C++函数重载和函数重写的区别，请举例说明

C++中的函数重载（function overloading）和函数重写（function overriding）是两种不同的概念，它们用于不同的编程场景，有着不同的特点。

函数重载（Function Overloading）：

函数重载是指在同一个类或命名空间中定义多个具有相同名称但参数列表不同的函数。编译器根据函数的参数类型、数量或顺序来选择调用合适的重载函数。

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }

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

在上面的示例中，Calculator类中有两个名为add的函数，一个接受两个整数参数，另一个接受两个双精度浮点数参数。这两个函数都有相同的名称但不同的参数列表，这就是函数重载。

函数重写（Function Overriding）：

  函数重写是指在子类中重新定义父类中已经存在的虚函数（通过关键字virtual声明的函数）。重写函数的名称、参数列表和返回类型都必须与父类中的虚函数完全匹配。函数重写实现了多态性，允许在运行时根据对象的实际类型来调用合适的函数

class Shape {
public:
    virtual void draw() {
        // 基类中的虚函数
        std::cout << "Drawing a shape." << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        // 子类中的重写虚函数
        std::cout << "Drawing a circle." << std::endl;
    }
};

 在上面的示例中，Shape类中定义了一个虚函数draw，而Circle类继承自Shape类并重写了draw函数。当通过Shape或Circle对象调用draw函数时，将根据对象的实际类型调用合适的函数。

总结：

• 函数重载是在同一类或命名空间中定义多个同名函数，根据参数的不同选择调用合适的函数，是静态多态性。
• 函数重写是子类重新定义父类中的虚函数，允许在运行时根据对象的实际类型来调用合适的函数，是动态多态性。

还是理解的不够深刻，再来一个例子

代码2

假设我们有一个基类Animal，它有一个虚函数makeSound，然后有两个派生类Dog和Cat，它们都继承自Animal类，并分别重写了makeSound函数。

#include 

class Animal {
public:
    // 虚函数
    virtual void makeSound() {
        std::cout << "This is an animal sound." << std::endl;
    }
};

class Dog : public Animal {
public:
    // 重写虚函数
    void makeSound() override {
        std::cout << "Dog barks: Woof! Woof!" << std::endl;
    }
};

class Cat : public Animal {
public:
    // 重写虚函数
    void makeSound() override {
        std::cout << "Cat meows: Meow! Meow!" << std::endl;
    }
};

int main() {
    Animal* animal1 = new Dog(); // 创建一个指向Dog对象的指针
    Animal* animal2 = new Cat(); // 创建一个指向Cat对象的指针

    animal1->makeSound(); // 调用Dog的makeSound函数
    animal2->makeSound(); // 调用Cat的makeSound函数

    delete animal1;
    delete animal2;

    return 0;
}

让我们一步一步解释这个示例：

1. 我们定义了一个基类Animal，其中有一个虚函数makeSound。虚函数的关键之一是它可以被派生类重写。

2. 我们创建了两个派生类Dog和Cat，它们都继承了Animal类，并重写了makeSound函数。每个子类都实现了自己的声音。

3. 在main函数中，我们创建了两个指向基类Animal对象的指针，但实际上它们分别指向了Dog和Cat的对象。这是多态性的体现，因为我们可以通过基类指针调用派生类的函数。

4. 当我们通过这些指针调用makeSound函数时，由于它是虚函数，并且根据对象的实际类型来选择调用的函数，所以将分别调用Dog和Cat的makeSound函数。

运行程序，输出如下：

Dog barks: Woof! Woof!
Cat meows: Meow! Meow!