C++ 中的 override 和 overload的区别

1.Overload(重载)

2.override(重写)

[3.override 和 overload 的根本区别](#3.override 和 overload 的根本区别)

[4.override 和 overload 的实际应用](#4.override 和 overload 的实际应用)

[5.override 和 overload 的常见误区](#5.override 和 overload 的常见误区)

6.总结

1.Overload(重载)

定义：在同一个作用域内，可以声明几个功能类似的函数名相同的函数，但是这些函数的参数列表不同（参数个数不同、参数类型不同、参数顺序不同等）。这就是函数重载（Function Overloading）。
目的：主要是为了提供函数使用的灵活性，便于记忆和使用。
实现：通过改变函数的参数列表来实现。
示例：

cpp 复制代码

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

在这个例子中，print 函数被重载了三次，分别接受 int、double 和 std::string 类型的参数。编译器根据传递的参数类型自动选择调用哪个函数。

C/C++中重载函数取地址的方法

2.override(重写)

定义：在派生类中，我们可以重写（Override）基类中的虚函数。这意呀着派生类提供了一个特定签名的成员函数，该函数与基类中的某个虚函数具有相同的名称、返回类型和参数列表。
目的：主要用于实现多态性。通过基类指针或引用，能够调用到派生类中的特定实现。
实现：通过在派生类的成员函数声明中使用override关键字（C++11及以后）来显式地指出该函数重写了基类中的虚函数。如果不使用override关键字，编译器也会隐式地检查，但使用override可以提高代码的可读性和安全性。
示例：

cpp 复制代码

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

class Derived : public Base {  
public:  
    void show() override { // 使用override关键字明确表示该函数重写了基类中的虚函数  
        std::cout << "Derived class show" << std::endl;  
    }  
};  

// 通过基类指针调用派生类的方法，体现了多态性

在上述代码中，Derived 类的 show() 函数使用了 override 关键字，明确表示它是对基类 Base 中虚函数的重写。编译器将检查函数签名是否与基类虚函数一致。

3.override 和 overload 的根本区别

概念上的区别

override（重写）： 是针对类的继承关系中的虚函数，它允许子类重新定义基类的虚函数行为。函数签名必须与基类中的虚函数一致。
overload（重载）： 是在同一作用域中定义多个同名函数，它们的参数列表不同，编译器通过参数的不同来区分这些函数。

作用域上的区别

override： 发生在继承体系中，子类继承自基类时，重写基类中的虚函数。
overload： 发生在同一类或同一作用域中，允许多个函数名相同但参数列表不同的函数并存。

编译器处理上的区别

override： 编译器会检查子类函数是否确实重写了基类的虚函数。如果签名不匹配，编译器将报错。
overload： 编译器会根据传递给函数的参数类型来选择正确的函数进行调用。

4.override 和 overload 的实际应用

override 的应用场景

override 常用于多态的实现，子类通过重写基类的虚函数来实现不同的行为，而不改变接口。这种方式允许我们利用面向对象的设计，实现代码的灵活性和可扩展性。

cpp 复制代码

class Shape {
    public:    
        virtual double area() const = 0; // 纯虚函数
};

class Circle : public Shape {
public:    
    Circle(double r) : radius(r) {}    
    double area() const override { // 重写纯虚函数        
        return 3.14159 * radius * radius;    
    }
private:    
    double radius;
};

在这个例子中，Shape 类定义了一个纯虚函数 area()，而 Circle 类重写了该函数，提供了圆形的面积计算方法。

overload 的应用场景

函数重载经常用于需要同一个函数执行类似的操作，但处理不同类型的参数时。例如，打印函数可以根据输入的类型打印不同的信息。

cpp 复制代码

class Logger {
public:    
    void log(int i) {       
         std::cout << "Logging int: " << i << std::endl;    
    }
    void log(double d) {        
        std::cout << "Logging double: " << d << std::endl;    
    }
    void log(const std::string& s) {        
        std::cout << "Logging string: " << s << std::endl;    
    }
};

函数重载的应用场景极为广泛，从数学运算、输入输出到模板类函数，重载为代码的灵活性提供了极大支持。

5.override 和 overload 的常见误区

override 中的隐藏函数问题

如果我们在子类中定义了一个与基类中非虚函数同名但参数不同的函数，并没有使用 override，那么此时基类中的函数将会被"隐藏"，而不是重载。这可能导致意外的行为。

cpp 复制代码

class Base {  
public:  
    virtual void func(int) {  
        std::cout << "Base class show" << std::endl;  
    }  
};  

class Derived : public Base {  
public:  
    void func(double)  const { // 隐藏了基类的 func(int) 
        std::cout << "Derived class show" << std::endl;  
    }  
};

在这个例子中，Derived 类定义了一个新的 func(double) 函数，这将隐藏基类的 func(int) 函数。在使用派生类时，如果传递 int 类型参数，调用的是 Base 的 func，而不是重载的版本。正确的做法是使用 using 来引入基类的重载版本。

overload 中的返回值问题

函数重载时，重载的区分条件是参数列表，而不是返回值类型。如果两个函数仅在返回值类型上不同，编译器会报错。

cpp 复制代码

int func(int);
double func(int); // 错误，返回类型不同

6.总结

在重写基类虚函数时，始终使用 override 关键字，确保编译器检查函数签名的正确性，避免意外的错误。
在进行函数重载时，确保参数列表的差异足以让编译器进行区分，同时保证函数的语义一致性。
如果需要在子类中使用基类的重载函数，使用 using 关键字显式引入基类的函数，避免隐藏问题。

总之，在 C++ 中，理解 override 和 overload 的区别是掌握面向对象编程的重要一步。override 强调的是子类对基类虚函数的重写，是实现多态的基础。而 overload 则允许同一作用域内定义多个功能类似但参数不同的函数。两者各司其职，合理运用可以大大提升代码的灵活性和可读性。