C++ 函数的类方法如何重载？

在C++中，类方法重载指的是在同一个类的作用域内，定义多个同名的方法，这些方法通过参数列表的差异来区分，从而让同一个方法名可以适配不同的输入场景，提升类的易用性。

类方法重载的核心规则

要实现有效的类方法重载，需要满足以下几个核心条件：

• 方法名必须完全相同，且属于同一个类的成员方法。
• 参数列表必须存在差异，差异可以是参数个数不同、参数类型不同，或者参数顺序不同（前提是参数类型本身不同）。
• 返回类型可以相同也可以不同，但仅返回类型不同不足以构成重载，必须配合参数列表的差异。
• 不能仅通过const修饰符来区分非引用非指针的返回类型，但对于成员方法本身，const修饰的成员方法和非const成员方法可以构成重载。

普通成员方法的重载示例

下面通过一个数据打印类的示例，展示普通成员方法的重载实现：

#include <iostream>
#include <string>

class DataPrinter {
public:
    // 重载方法1：打印整数
    void print(int num) {
        std::cout << "整数: " << num << std::endl;
    }

    // 重载方法2：打印字符串，参数类型不同
    void print(const std::string& str) {
        std::cout << "字符串: " << str << std::endl;
    }

    // 重载方法3：打印两个整数，参数个数不同
    void print(int a, int b) {
        std::cout << "两个整数: " << a << ", " << b << std::endl;
    }

    // 重载方法4：参数顺序不同，注意参数类型本身不同
    void print(int num, const std::string& str) {
        std::cout << "整数和字符串: " << num << ", " << str << std::endl;
    }

    void print(const std::string& str, int num) {
        std::cout << "字符串和整数: " << str << ", " << num << std::endl;
    }
};

int main() {
    DataPrinter printer;
    printer.print(10);
    printer.print("hello");
    printer.print(20, 30);
    printer.print(40, "test");
    printer.print("demo", 50);
    return 0;
}

构造方法的重载

构造方法是类方法中重载场景最频繁的类型之一，通过重载构造方法可以让对象初始化有不同的路径：

#include <iostream>
#include <string>

class Person {
private:
    std::string name;
    int age;

public:
    // 无参构造
    Person() : name("未知"), age(0) {}

    // 仅传入姓名的构造
    Person(const std::string& n) : name(n), age(0) {}

    // 传入姓名和年龄的构造
    Person(const std::string& n, int a) : name(n), age(a) {}

    void showInfo() {
        std::cout << "姓名: " << name << ", 年龄: " << age << std::endl;
    }
};

int main() {
    Person p1;
    Person p2("张三");
    Person p3("李四", 25);

    p1.showInfo();
    p2.showInfo();
    p3.showInfo();
    return 0;
}

const成员方法的重载

类的const成员方法和非const成员方法可以构成重载，编译器会根据调用对象是否是const类型来选择对应的方法：

#include <iostream>
#include <string>

class MyClass {
private:
    int value;

public:
    MyClass(int v) : value(v) {}

    // 非const成员方法
    int getValue() {
        std::cout << "调用非const版本的getValue" << std::endl;
        return value;
    }

    // const成员方法，构成重载
    int getValue() const {
        std::cout << "调用const版本的getValue" << std::endl;
        return value;
    }
};

int main() {
    MyClass obj1(10);
    const MyClass obj2(20);

    obj1.getValue(); // 调用非const版本
    obj2.getValue(); // 调用const版本
    return 0;
}

运算符重载作为类方法重载的特殊场景

运算符重载本质上是特殊的类方法重载，运算符作为方法名，通过参数列表适配不同的运算场景：

#include <iostream>

class Vector {
private:
    int x, y;

public:
    Vector(int x = 0, int y = 0) : x(x), y(y) {}

    // 重载+运算符，作为成员方法
    Vector operator+(const Vector& other) const {
        return Vector(x + other.x, y + other.y);
    }

    // 重载*运算符，支持向量和标量的乘法
    Vector operator*(int scalar) const {
        return Vector(x * scalar, y * scalar);
    }

    void show() {
        std::cout << "(" << x << ", " << y << ")" << std::endl;
    }
};

int main() {
    Vector v1(1, 2);
    Vector v2(3, 4);
    Vector v3 = v1 + v2;
    Vector v4 = v1 * 3;

    v3.show();
    v4.show();
    return 0;
}

重载与重写的区别

很多开发者容易混淆重载和重写，二者的核心差异如下：

常见注意事项

• 不要仅仅通过返回类型不同来尝试重载方法，这会导致编译错误。
• 重载的方法应该具有相似的功能，避免同一个方法名对应完全不相关的逻辑，降低代码可读性。
• 默认参数会影响重载的匹配，比如同时定义了void func(int a)和void func(int a, int b = 0)，在调用func(1)时会产生二义性，编译不通过。
• 运算符重载时要遵循运算符原本的语义，不要滥用重载实现不符合直觉的功能。

C++重载类方法重载函数重载运算符重载修改时间：2026-07-03 23:12:13