前言： 在C++编程中，多态性是实现面向对象编程的重要特性，它允许不同类型的对象对同一消息做出不同的响应。函数重载（Overloading）、函数覆盖（Overriding）和函数隐藏（Hiding）是实现多态的三种不同方式。尽管它们名称相近，但实现原理和使用场景存在显著差异。本文将详细探讨这三种机制的区别与应用。

一、函数重载

1.1、定义

函数重载是指在同一作用域内可以定义多个同名函数，但这些函数的参数列表必须不同（参数数量、类型或顺序不同）。重载是C++实现编译时多态（静态多态）的主要方式。

注意： 函数的返回类型不参与重载的判断。

1.2、const关键字与重载

• 普通函数重载与const：

当两个函数同名，一个参数为const修饰，另一个为非const修饰时，它们构成重载关系。例如：

void print(const char* text)
{
    std::cout << "Const version: " << text << std::endl;
}

void print(char* text)
{
    std::cout << "Non-const version: " << text << std::endl;
}

• 成员函数的const重载

在类中，当成员函数的const修饰不同时，它们也构成重载。例如：

class TextPrinter
{
public:
    void output()
    {
        std::cout << "Mutable output" << std::endl;
    }
    
    void output() const
    {
        std::cout << "Const output" << std::endl;
    }
};

1.3、实现原理

C++函数重载的实现依赖于编译器的名称修饰（Name Mangling）机制。编译器在编译过程中会根据函数的参数列表生成唯一的内部名称，这些名称包含了函数名、参数类型、参数数量等信息。即使函数名相同，只要参数列表不同，编译器就能为它们生成不同的修饰名，从而在链接阶段正确区分和调用相应的函数。

二、函数覆盖

2.1、定义

函数覆盖是指派生类重新实现基类的虚函数，当通过基类指针或引用调用该函数时，将执行派生类的版本。覆盖是实现运行时多态（动态多态）的基础。

例如：

class Animal {
public:
    virtual void makeSound() {
        std::cout << "Generic animal sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        std::cout << "Woof! Woof!" << std::endl;
    }
};

2.2、覆盖的条件

• 继承关系： 必须存在基类和派生类的继承关系。
• 虚函数： 基类中的函数必须声明为virtual。
• 函数签名一致： 派生类中的函数必须与基类虚函数具有相同的名称、参数列表和返回类型。
• 访问权限： 派生类中的覆盖函数可以有不同的访问权限，但这通常不推荐，因为它可能影响代码的可读性。

2.3、override关键字的作用

C++11引入了override关键字，用于明确表示派生类成员函数是对基类虚函数的覆盖。使用override可以：

• 让编译器检查函数签名是否正确匹配
• 避免因函数签名不匹配导致的意外隐藏
• 提高代码可读性

例如：

class Shape {
public:
    virtual double calculateArea() const {
        return 0.0;
    }
    
    virtual void draw() const {
        std::cout << "Drawing a generic shape" << std::endl;
    }
};

class Circle : public Shape {
public:
    double calculateArea() const override {
        return radius * radius * 3.14159;
    }
    
    void draw() const override {
        std::cout << "Drawing a circle" << std::endl;
    }
    
private:
    double radius;
};

三、函数隐藏

3.1、定义

函数隐藏是指在继承关系中，当派生类的函数与基类的函数同名时，无论参数列表是否相同，派生类的函数都会隐藏基类的同名函数。这意味着通过派生类对象只能访问派生类的版本。

3.2、隐藏的条件

• 同名： 派生类中的成员与基类中的成员名称相同。
• 不同作用域： 隐藏发生在基类和派生类这两个不同的作用域中。
• 参数列表可同可不同： 即使参数列表相同，只要函数名相同，就会发生隐藏。
• 与虚函数无关： 隐藏与基类函数是否为虚函数无关。

3.3、隐藏与覆盖的区别

特性	函数隐藏	函数覆盖
基类函数是否为虚	不需要	必须是虚函数
函数签名	可同可不同	必须相同
多态性	不支持	支持运行时多态
访问方式	通过派生类对象访问派生类版本	通过基类指针/引用访问派生类版本

3.4、示例

class Vehicle {
public:
    void move() {
        std::cout << "Vehicle is moving" << std::endl;
    }
    
    void transport(int passengers) {
        std::cout << "Vehicle transporting " << passengers << " passengers" << std::endl;
    }
};

class Car : public Vehicle {
public:
    void move(int speed) { // 隐藏了基类的move()函数
        std::cout << "Car is moving at " << speed << " km/h" << std::endl;
    }
    
    void transport(double weight) { // 隐藏了基类的transport(int)函数
        std::cout << "Car transporting " << weight << " kg" << std::endl;
    }
};

int main() {
    Car myCar;
    myCar.move(100); // 调用Car类的move(int)
    // myCar.move(); // 错误：基类的move()被隐藏
    
    myCar.transport(500.0); // 调用Car类的transport(double)
    // myCar.transport(4); // 错误：基类的transport(int)被隐藏
    
    Vehicle* vehicle = &myCar;
    vehicle->move(); // 调用基类的move()
    vehicle->transport(4); // 调用基类的transport(int)
    
    return 0;
}

通过上述示例可以看出，当通过基类指针访问时，会调用基类的版本；而当通过派生类对象直接访问时，只能访问派生类的版本，这就是函数隐藏的特性。

理解函数重载、覆盖和隐藏的区别对于编写高效、可维护的C++代码至关重要。正确使用这些机制可以充分发挥C++面向对象编程的优势，提高代码的灵活性和可扩展性。