C++函数重载详解

C++中的函数重载（Function Overloading）是一种允许在同一作用域内定义多个同名函数，但这些函数的参数列表（参数个数或类型）不同的特性。函数重载是C++实现多态性的一种方式，主要用于提高代码的可读性和可维护性。下面详细讲解函数重载的各个方面。

1. 函数重载的基本概念

函数重载允许你在同一个作用域内定义多个具有相同名称但参数列表不同的函数。编译器通过函数调用时提供的实参的个数和类型来确定应该调用哪个重载的函数。函数的返回类型不参与重载决策。

2. 函数重载的规则

函数重载的实现主要依赖于以下几个规则：

参数个数不同

可以通过改变参数的个数来重载函数。

#include <iostream>
using namespace std;
​
void print() {
    cout << "No arguments" << endl;
}
​
void print(int i) {
    cout << "Integer: " << i << endl;
}
​
void print(int i, int j) {
    cout << "Two integers: " << i << " and " << j << endl;
}
​
int main() {
    print();         // 调用 void print()
    print(5);        // 调用 void print(int)
    print(5, 10);    // 调用 void print(int, int)
    return 0;
}

参数类型不同

可以通过改变参数的类型来重载函数。

#include <iostream>
using namespace std;
​
void display(int i) {
    cout << "Integer: " << i << endl;
}
​
void display(double d) {
    cout << "Double: " << d << endl;
}
​
void display(char c) {
    cout << "Character: " << c << endl;
}
​
int main() {
    display(5);       // 调用 void display(int)
    display(3.14);    // 调用 void display(double)
    display('A');     // 调用 void display(char)
    return 0;
}

参数顺序不同

可以通过改变参数的顺序来重载函数（前提是参数类型不同）。

#include <iostream>
using namespace std;
​
void show(int i, double d) {
    cout << "Integer and double: " << i << ", " << d << endl;
}
​
void show(double d, int i) {
    cout << "Double and integer: " << d << ", " << i << endl;
}
​
int main() {
    show(5, 3.14);    // 调用 void show(int, double)
    show(3.14, 5);    // 调用 void show(double, int)
    return 0;
}

3. 构造函数重载

构造函数可以重载以提供不同的对象初始化方式。

#include <iostream>
using namespace std;
​
class Box {
private:
    double length, breadth, height;
​
public:
    // 默认构造函数
    Box() {
        length = breadth = height = 0.0;
    }
​
    // 带参数的构造函数
    Box(double l, double b, double h) {
        length = l;
        breadth = b;
        height = h;
    }
​
    void display() {
        cout << "Box dimensions: " << length << " x " << breadth << " x " << height << endl;
    }
};
​
int main() {
    Box box1;                // 调用默认构造函数
    Box box2(3.0, 4.0, 5.0); // 调用带参数的构造函数
​
    box1.display();
    box2.display();
​
    return 0;
}

4. 运算符重载

运算符重载允许自定义类型的对象使用类似于内置类型的运算符。

#include <iostream>
using namespace std;
​
class Complex {
private:
    double real, imag;
​
public:
    Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
​
    // 重载加法运算符
    Complex operator + (const Complex& c) {
        return Complex(real + c.real, imag + c.imag);
    }
​
    void display() {
        cout << "Real: " << real << ", Imaginary: " << imag << endl;
    }
};
​
int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;  // 使用运算符重载
​
    c3.display();  // 输出：Real: 4.0, Imaginary: 6.0
​
    return 0;
}

5. 注意事项

1. 返回类型不能用于区分重载函数：

   int func(int i);
   double func(int i);  // 错误：仅返回类型不同

2. 函数默认参数与重载：

   void func(int i, int j = 10);  // 有默认参数
   ​
   void func(int i);  // 错误：与默认参数的重载冲突

总结

函数重载是一种使代码更具可读性和灵活性的重要特性。它允许在同一作用域内定义多个同名函数，并通过参数的个数和类型区分这些函数。在设计函数重载时，要注意避免因参数类型过于接近而导致的调用混淆，确保函数重载能够清晰地表达不同的功能。