在C++的类设计中，默认参数和重载函数是优化成员函数调用体验、提升代码复用性的重要手段。默认参数允许调用者在调用函数时省略部分实参，重载函数则允许同一个函数名对应不同的参数列表，两者在类中的实现和普通函数有一定区别，需要遵循特定的语法规则。
类中默认参数的实现规则
类的成员函数如果要使用默认参数，默认参数的声明必须放在函数的声明部分，通常是类的头文件中的函数声明处，而不能放在类外的函数定义处。这是因为编译器在编译调用该函数的代码时，需要先知道默认参数的值，才能正确生成函数调用的指令。
默认参数的声明位置
如果类的定义和成员函数的定义是分开的，默认参数只能出现在类的内部声明中，类外的定义不能重复指定默认参数，否则会导致编译错误。
// 类的头文件 example.h
class Example {
public:
// 默认参数在类内声明处指定
void print(int a, int b = 10);
};
// 类外定义，不能再次指定默认参数
void Example::print(int a, int b) {
// 打印参数值
std::cout << "a: " << a << ", b: " << b << std::endl;
}
默认参数的作用顺序
默认参数必须从右向左依次指定，也就是说，如果一个参数有默认值，那么它右边所有的参数都必须有默认值。这个规则和普通函数的默认参数规则一致，在类中同样适用。
class Demo {
public:
// 正确：默认参数从右向左，b有默认值，c也有默认值
void func(int a, int b = 20, int c = 30);
// 错误：b有默认值但c没有，编译会报错
// void func2(int a, int b = 20, int c);
};
类中重载函数的实现方式
类的重载函数和普通的重载函数逻辑一致，只要同一个类中的多个成员函数满足函数名相同，但参数列表不同（参数类型、参数个数、参数顺序不同）即可，返回值类型不同不能作为重载的依据。
参数个数不同的重载
通过不同的参数个数实现重载，是最常见的重载场景。
class Calculator {
public:
// 两个参数相加
int add(int a, int b) {
return a + b;
}
// 三个参数相加，重载add函数
int add(int a, int b, int c) {
return a + b + c;
}
};
参数类型不同的重载
参数类型不同也可以实现重载，比如同一个函数名可以接收int类型和double类型的参数。
class DataHandler {
public:
void handle(int val) {
std::cout << "处理整数: " << val << std::endl;
}
void handle(double val) {
std::cout << "处理浮点数: " << val << std::endl;
}
};
默认参数与重载函数同时使用的注意事项
当类中同时使用了默认参数和重载函数时，很容易出现函数调用的二义性，导致编译器无法确定调用哪个函数，从而编译报错。
二义性问题示例
下面的代码中，两个函数构成重载，但因为默认参数的存在，调用func(10)时编译器无法判断是调用第一个函数还是第二个函数。
class AmbiguousCase {
public:
void func(int a) {
std::cout << "调用func(int)" << std::endl;
}
// 有默认参数，省略第二个参数时和上面的函数参数匹配冲突
void func(int a, int b = 20) {
std::cout << "调用func(int, int)" << std::endl;
}
};
int main() {
AmbiguousCase obj;
// 编译报错：调用func(10)有二义性
// obj.func(10);
// 正确调用，明确传递两个参数
obj.func(10, 20);
return 0;
}
避免二义性的方法
要避免这种二义性，需要合理设计函数的参数列表，尽量不要让默认参数导致重载函数的参数匹配出现重叠。如果确实需要同时使用默认参数和重载，可以通过调整参数类型、增加无默认值的参数等方式区分不同的重载版本。
完整示例代码
下面是一个综合使用类中默认参数和重载函数的完整示例，展示了正确的用法和调用方式。
#include <iostream>
#include <string>
class User {
private:
std::string name;
int age;
public:
// 构造函数使用默认参数
User(std::string n = "默认用户", int a = 18) : name(n), age(a) {}
// 重载showInfo函数，参数个数不同
void showInfo() {
std::cout << "姓名: " << name << ", 年龄: " << age << std::endl;
}
void showInfo(std::string prefix) {
std::cout << prefix << " 姓名: " << name << ", 年龄: " << age << std::endl;
}
// 重载setInfo函数，参数类型不同
void setInfo(std::string n) {
name = n;
}
void setInfo(int a) {
age = a;
}
};
int main() {
// 使用构造函数的默认参数
User user1;
user1.showInfo();
// 传递部分参数，使用构造函数的默认参数
User user2("张三");
user2.showInfo();
// 调用带参数的重载函数
user2.showInfo("用户信息：");
// 调用不同参数类型的重载函数
user2.setInfo(20);
user2.showInfo();
return 0;
}
通过上述内容可以看出，类中实现默认参数和重载函数的核心规则和普通函数类似，但需要注意默认参数的声明位置、默认参数的顺序，以及两者同时使用时避免二义性问题。合理运用这两个特性，可以让类的接口更友好，代码更易维护。