C++函数默认参数的使用误区

函数默认参数的基本概念

在C++ 中，函数默认参数为程序员提供了一种便捷的方式，使函数在调用时某些参数可以不必显式指定。当函数调用中省略了这些参数时，编译器会自动使用预先设定的默认值。例如：

#include <iostream>

// 带有默认参数的函数
void printMessage(const char* message = "Hello, World!") {
    std::cout << message << std::endl;
}

int main() {
    printMessage(); // 使用默认参数
    printMessage("Custom message"); // 覆盖默认参数
    return 0;
}

在上述代码中，printMessage 函数定义了一个默认参数 message。当在 main 函数中调用 printMessage 时，如果不传递参数，就会使用默认的消息 "Hello, World!"；若传递参数，则使用传递的自定义消息。

默认参数的定义位置

默认参数可以在函数声明或定义中指定，但不能在声明和定义中同时重复指定。通常，建议在函数声明中指定默认参数，这样在调用函数的代码中就能清晰地看到默认值。例如：

// 函数声明，指定默认参数
void setValue(int num = 0);

// 函数定义
void setValue(int num) {
    std::cout << "The value is: " << num << std::endl;
}

int main() {
    setValue(); // 使用默认值 0
    setValue(5); // 传递值 5
    return 0;
}

如果在函数声明和定义中都指定默认参数，编译器会报错。如下面的代码会导致编译错误：

// 函数声明，指定默认参数
void setValue(int num = 0);

// 函数定义，再次指定默认参数（错误）
void setValue(int num = 1) {
    std::cout << "The value is: " << num << std::endl;
}

默认参数的顺序

默认参数必须从右至左依次定义。也就是说，在函数参数列表中，一旦某个参数被赋予了默认值，它右边的所有参数都必须有默认值。例如：

// 正确：默认参数从右至左
void calculate(int a, int b = 2, int c = 3) {
    std::cout << "a + b + c = " << a + b + c << std::endl;
}

// 错误：默认参数顺序错误
// void calculate(int a = 1, int b, int c = 3) {
//     std::cout << "a + b + c = " << a + b + c << std::endl;
// }

在 calculate 函数的正确定义中，b 和 c 有默认值，且位于 a 的右侧。如果像注释掉的代码那样，a 有默认值而 b 没有，就会违反默认参数从右至左的规则，导致编译错误。

默认参数与函数重载的混淆

重载函数与默认参数的表面相似性

函数重载是指在同一作用域内，可以有多个同名函数，但它们的参数列表不同（参数个数或类型不同）。默认参数有时会与函数重载产生混淆，因为在某些情况下，它们都能实现类似的功能，即让函数在调用时可以接受不同数量或类型的参数。例如：

// 函数重载
void printNumber(int num) {
    std::cout << "Integer: " << num << std::endl;
}

void printNumber(double num) {
    std::cout << "Double: " << num << std::endl;
}

// 带有默认参数的函数
void printValue(int num, double factor = 1.0) {
    std::cout << "Value: " << num * factor << std::endl;
}

在上述代码中，printNumber 函数通过函数重载实现了接受不同类型参数的功能；而 printValue 函数通过默认参数实现了在不传递第二个参数时使用默认值的功能。从调用的角度看，两者都能适应不同的调用方式。

混淆产生的错误调用

然而，当函数重载和默认参数同时存在时，很容易产生混淆并导致错误调用。例如：

void printData(int num) {
    std::cout << "Printing integer: " << num << std::endl;
}

void printData(int num, double value = 0.0) {
    std::cout << "Printing integer and double: " << num << ", " << value << std::endl;
}

int main() {
    printData(5); // 调用哪个函数？
    return 0;
}

在 main 函数中调用 printData(5) 时，编译器会优先匹配最精确的函数，也就是 printData(int num)。但如果程序员本意是调用带有默认参数的 printData(int num, double value) 函数，就会导致逻辑错误。这种混淆在大型项目中更难排查，因为函数调用可能在不同的源文件中，且函数声明和定义可能分离。

避免混淆的方法

为了避免这种混淆，首先要明确函数重载和默认参数的设计意图。函数重载通常用于处理不同类型或不同数量参数的本质不同的操作，而默认参数用于提供一种常见情况下的便捷调用方式。在设计函数时，要根据实际需求合理选择使用函数重载还是默认参数。如果必须同时使用，要确保函数的调用逻辑清晰，避免出现歧义。例如，可以给重载函数和带有默认参数的函数取不同的名字，或者通过文档清晰地说明每个函数的用途和调用方式。

默认参数的作用域和可见性问题

默认参数与局部变量

默认参数在函数声明或定义时确定，其作用域与函数的参数列表相关。但当默认参数涉及到局部变量时，就可能出现问题。例如：

#include <iostream>

void testFunction(int num = localVar) {
    int localVar = 10;
    std::cout << "Number: " << num << std::endl;
}

int main() {
    testFunction();
    return 0;
}

在上述代码中，试图在默认参数中使用局部变量 localVar。但在函数声明时，localVar 还未定义，这会导致编译错误。默认参数的值必须在函数声明或定义时就能够确定，不能依赖于函数内部的局部变量。

默认参数与全局变量

虽然可以在默认参数中使用全局变量，但也要注意全局变量的可见性和可修改性可能带来的问题。例如：

#include <iostream>

int globalVar = 5;

void printValue(int num = globalVar) {
    std::cout << "Value: " << num << std::endl;
}

int main() {
    printValue();
    globalVar = 10;
    printValue();
    return 0;
}

在上述代码中，printValue 函数的默认参数使用了全局变量 globalVar。第一次调用 printValue 时，使用的是 globalVar 的初始值 5；当 globalVar 的值在 main 函数中被修改为 10 后，再次调用 printValue，使用的就是修改后的值 10。这种依赖全局变量的默认参数可能会导致函数行为的不确定性，尤其是在多线程环境下，全局变量可能被多个线程同时修改。

类成员函数的默认参数

对于类成员函数的默认参数，同样需要注意作用域和可见性。类成员函数的默认参数可以访问类的成员变量，但要注意访问权限。例如：

class MyClass {
private:
    int memberVar;
public:
    MyClass(int value) : memberVar(value) {}
    void printValue(int num = memberVar) {
        std::cout << "Value: " << num << std::endl;
    }
};

int main() {
    MyClass obj(15);
    obj.printValue();
    return 0;
}

在上述代码中，printValue 函数是 MyClass 的成员函数，其默认参数 num 使用了类的私有成员变量 memberVar。这是合法的，因为成员函数可以访问类的私有成员。但如果在类外定义成员函数时指定默认参数，就需要注意作用域和访问权限的问题。例如：

class MyClass {
private:
    int memberVar;
public:
    MyClass(int value) : memberVar(value) {}
    void printValue(int num);
};

// 类外定义成员函数并指定默认参数（错误）
// void MyClass::printValue(int num = memberVar) {
//     std::cout << "Value: " << num << std::endl;
// }

在类外定义 printValue 函数并指定默认参数时，会出现编译错误，因为此时 memberVar 的作用域和访问权限与类内不同。正确的做法是在类内声明时指定默认参数，或者在类外定义时不使用类的成员变量作为默认参数。

默认参数与模板函数

模板函数中的默认参数

C++ 模板函数也可以有默认参数，这为代码的通用性提供了更多可能。例如：

#include <iostream>

template <typename T, T defaultValue = 0>
T getValue() {
    return defaultValue;
}

int main() {
    int result1 = getValue<int>();
    int result2 = getValue<int, 5>();
    double result3 = getValue<double, 3.14>();
    std::cout << "Result1: " << result1 << std::endl;
    std::cout << "Result2: " << result2 << std::endl;
    std::cout << "Result3: " << result3 << std::endl;
    return 0;
}

在上述代码中，getValue 是一个模板函数，它有一个类型参数 T 和一个默认参数 defaultValue。通过指定不同的模板参数，可以获取不同类型和不同默认值的结果。

模板函数默认参数的特殊问题

然而，模板函数的默认参数也可能带来一些特殊问题。例如，当模板函数的默认参数依赖于其他模板参数时，可能会出现编译错误或意外的行为。考虑以下代码：

template <typename T, typename U = T>
void printPair(T first, U second) {
    std::cout << "First: " << first << ", Second: " << second << std::endl;
}

int main() {
    printPair(5, 10); // 正常调用
    printPair(5); // 错误调用，无法推断 U 的类型
    return 0;
}

在上述代码中，printPair 模板函数有两个类型参数 T 和 U，U 的默认值依赖于 T。当调用 printPair(5, 10) 时，编译器可以根据传入的参数推断出 T 和 U 的类型。但当调用 printPair(5) 时，编译器无法推断出 U 的类型，因为虽然 U 有默认值 T，但 T 也需要根据参数推断，这就导致了编译错误。

解决模板函数默认参数问题的方法

为了解决这类问题，通常需要在调用模板函数时显式指定模板参数，或者通过其他方式让编译器能够明确推断出模板参数的类型。例如，可以修改上述代码为：

template <typename T, typename U = T>
void printPair(T first, U second) {
    std::cout << "First: " << first << ", Second: " << second << std::endl;
}

int main() {
    printPair<int, int>(5, 10);
    printPair<int>(5, 10); // 可以省略 U 的类型，因为有默认值
    return 0;
}

通过显式指定模板参数，或者利用默认参数的特性，确保编译器能够正确推断类型，从而避免因模板函数默认参数带来的编译错误。

默认参数在继承与多态中的问题

基类与派生类中的默认参数

在继承体系中，基类的成员函数若有默认参数，派生类继承该函数时，默认参数的行为可能会引发问题。例如：

class Base {
public:
    virtual void printMessage(const char* message = "Base message") {
        std::cout << "Base: " << message << std::endl;
    }
};

class Derived : public Base {
public:
    void printMessage(const char* message = "Derived message") override {
        std::cout << "Derived: " << message << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->printMessage();
    delete basePtr;
    return 0;
}

在上述代码中，Base 类的 printMessage 函数有一个默认参数，Derived 类重写了该函数并提供了不同的默认参数。当通过基类指针调用 printMessage 函数时，虽然实际调用的是派生类的函数，但使用的是基类的默认参数，输出为 "Base: Base message"。这是因为默认参数是在编译时确定的，而函数的实际调用是在运行时根据对象的实际类型确定的。

解决继承中默认参数问题的方法

为了避免这种问题，在设计继承体系时，尽量不要在基类和派生类的虚函数中同时使用默认参数。如果确实需要默认参数，可以考虑将默认参数的处理移到非虚函数中，通过虚函数调用非虚函数来实现。例如：

class Base {
public:
    virtual void printMessage(const char* message) {
        printMessageImpl(message);
    }
private:
    void printMessageImpl(const char* message = "Base message") {
        std::cout << "Base: " << message << std::endl;
    }
};

class Derived : public Base {
public:
    void printMessage(const char* message) override {
        printMessageImpl(message);
    }
private:
    void printMessageImpl(const char* message = "Derived message") {
        std::cout << "Derived: " << message << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->printMessage();
    delete basePtr;
    return 0;
}

在上述修改后的代码中，通过将默认参数的处理放在私有非虚函数 printMessageImpl 中，虚函数 printMessage 调用 printMessageImpl。这样，通过基类指针调用 printMessage 时，实际调用的是派生类的 printMessageImpl 函数，使用的是派生类的默认参数，输出为 "Derived: Derived message"。

多态与默认参数的结合使用

在多态的场景下，默认参数与动态绑定的结合需要谨慎处理。由于默认参数是在编译时确定的，而多态是基于运行时的对象类型。例如，假设有一个基类 Shape 和派生类 Circle、Rectangle，Shape 类有一个绘制函数 draw 带有默认参数：

class Shape {
public:
    virtual void draw(int color = 0) {
        std::cout << "Drawing shape with color " << color << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw(int color = 1) override {
        std::cout << "Drawing circle with color " << color << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw(int color = 2) override {
        std::cout << "Drawing rectangle with color " << color << std::endl;
    }
};

int main() {
    Shape* shapes[3];
    shapes[0] = new Circle();
    shapes[1] = new Rectangle();
    shapes[2] = new Shape();

    for (int i = 0; i < 3; ++i) {
        shapes[i]->draw();
    }

    for (int i = 0; i < 3; ++i) {
        delete shapes[i];
    }

    return 0;
}

在上述代码中，虽然 Circle 和 Rectangle 类重写了 draw 函数并提供了不同的默认参数，但在通过基类指针调用 draw 函数时，使用的是基类 Shape 的默认参数 color = 0。这可能与预期不符，如果希望使用派生类的默认参数，就需要调整设计，比如采用前面提到的将默认参数处理移到非虚函数的方式。

默认参数与编译优化

默认参数对编译优化的影响

默认参数会影响编译器的优化策略。当函数有默认参数时，编译器需要生成额外的代码来处理参数的默认值。例如，考虑以下简单的函数：

void addNumbers(int a, int b = 1) {
    std::cout << "Sum: " << a + b << std::endl;
}

编译器在编译这个函数时，需要考虑调用该函数时是否传递了第二个参数。如果没有传递，就使用默认值 1。这种额外的逻辑处理会增加函数的代码体积和编译时间。在大型项目中，大量使用默认参数可能会导致编译时间显著增加，尤其是在函数被频繁调用的情况下。

优化默认参数相关的编译

为了优化与默认参数相关的编译，可以采取以下措施。首先，如果默认参数的值在编译时是常量，编译器可能会进行一些优化。例如：

constexpr int defaultFactor = 2;

void multiplyNumbers(int a, int factor = defaultFactor) {
    std::cout << "Product: " << a * factor << std::endl;
}

在上述代码中，defaultFactor 是一个 constexpr 常量，编译器可能会在编译时就计算出 a * factor 的值，从而减少运行时的计算量。

其次，可以将不常用的默认参数放在函数重载中，而不是直接作为默认参数。例如：

void processData(int num) {
    // 处理数据的主要逻辑
    std::cout << "Processing data: " << num << std::endl;
}

void processData(int num, bool flag) {
    if (flag) {
        // 特殊处理逻辑
        std::cout << "Processing data with flag: " << num << std::endl;
    } else {
        processData(num);
    }
}

在上述代码中，processData 函数通过函数重载实现了对不同情况的处理，避免了使用默认参数带来的额外编译负担。

链接期与默认参数

在链接期，默认参数也可能带来一些问题。当函数的声明和定义在不同的源文件中，且默认参数在声明中指定时，如果声明文件中的默认参数值发生变化，而定义文件没有重新编译，可能会导致运行时错误。例如：

// file1.h
void printValue(int num = 5);

// file1.cpp
#include <iostream>
#include "file1.h"

void printValue(int num) {
    std::cout << "Value: " << num << std::endl;
}

// main.cpp
#include "file1.h"

int main() {
    printValue();
    return 0;
}

假设在项目开发过程中，file1.h 中的默认参数 num 从 5 改为 10，但 file1.cpp 没有重新编译。在链接时，main.cpp 会链接到旧版本的 printValue 函数，仍然使用默认值 5，这就导致了运行时的结果与预期不符。为了避免这种问题，当默认参数发生变化时，相关的源文件都应该重新编译。

默认参数在跨平台和跨编译器中的差异

不同编译器对默认参数的处理

不同的 C++ 编译器对默认参数的处理可能存在细微差异。例如，在一些较老的编译器中，对默认参数的类型检查可能不如现代编译器严格。考虑以下代码：

void testFunction(int num = 3.14) {
    std::cout << "Number: " << num << std::endl;
}

在现代编译器中，上述代码会因为类型不匹配（将 double 类型的 3.14 赋值给 int 类型的 num）而报错。但在一些早期的编译器中，可能会进行隐式类型转换而不报错，这可能导致程序出现意外行为。

此外，不同编译器对默认参数的优化策略也可能不同。一些编译器可能更积极地对默认参数进行优化，减少代码体积和运行时开销；而另一些编译器可能相对保守，保留更多与默认参数处理相关的代码。

跨平台开发中的默认参数问题

在跨平台开发中，默认参数也可能带来问题。不同操作系统对函数调用约定可能不同，这可能影响默认参数的传递方式。例如，在 Windows 平台上常用的 __cdecl 和 __stdcall 调用约定，以及在 Linux 平台上常用的 __fastcall 等，它们对参数传递的顺序和方式有不同的规定。当函数带有默认参数时，这些差异可能导致函数在不同平台上的行为不一致。

为了确保代码在跨平台和跨编译器环境下的一致性，一方面要遵循标准的 C++ 规范，尽量避免使用可能导致编译器特定行为的默认参数用法。另一方面，可以通过编写测试用例，在不同的编译器和平台上进行测试，及时发现并解决因默认参数处理差异带来的问题。

兼容性处理

如果项目需要在多种编译器和平台上运行，对于默认参数的兼容性处理可以采用以下方法。首先，可以使用编译器特定的宏来处理一些差异。例如：

#ifdef _MSC_VER // Visual Studio 编译器
__declspec(dllexport) void testFunction(int num = 5);
#else
void testFunction(int num = 5);
#endif

在上述代码中，通过 _MSC_VER 宏判断是否为 Visual Studio 编译器，如果是，则使用 __declspec(dllexport) 修饰函数声明，以满足 Windows 平台下动态链接库的导出需求。

其次，可以封装与默认参数相关的功能，将可能出现差异的部分隔离在一个模块中，便于针对不同平台和编译器进行调整。例如，将带有默认参数的函数封装在一个类中，在类的实现中根据平台和编译器的不同进行不同的处理。这样，在项目的其他部分调用该类的接口时，就可以避免直接受到默认参数兼容性问题的影响。

默认参数在性能敏感场景中的考量

默认参数对性能的潜在影响

在性能敏感的场景中，如实时系统、游戏开发等，默认参数可能对性能产生不可忽视的影响。前面提到，默认参数会增加函数的代码体积，因为编译器需要生成额外的代码来处理参数的默认值。在频繁调用的函数中，这种额外的代码体积可能导致缓存命中率降低，从而影响性能。

例如，在一个实时渲染的游戏引擎中，有一个函数用于计算物体的位置：

void calculatePosition(float x, float y, float z = 0.0f) {
    // 复杂的位置计算逻辑
    //...
}

如果这个函数在每一帧都被频繁调用，编译器为处理默认参数 z 生成的额外代码可能会占用一定的 CPU 时间和内存空间，影响渲染的帧率。

性能优化策略

为了在性能敏感场景中优化默认参数的使用，可以采取以下策略。一种方法是将默认参数转换为函数重载。例如，上述 calculatePosition 函数可以改为：

void calculatePosition(float x, float y) {
    calculatePosition(x, y, 0.0f);
}

void calculatePosition(float x, float y, float z) {
    // 复杂的位置计算逻辑
    //...
}

通过这种方式，在不传递 z 参数时，实际调用的是第一个重载函数，它直接调用第二个重载函数并传递默认值 0.0f。这样做的好处是，编译器可以针对不同的重载函数进行更优化的代码生成，避免了默认参数带来的额外开销。

另一种策略是在性能关键的代码段中，避免使用默认参数，而是显式传递参数。例如，在一个高性能的数值计算库中，函数的调用可能如下：

// 不使用默认参数
double calculateResult(double a, double b, double c) {
    // 复杂的数值计算
    return a * b + c;
}

// 在性能关键代码段中显式传递参数
void performanceCriticalSection() {
    double result1 = calculateResult(1.0, 2.0, 3.0);
    double result2 = calculateResult(4.0, 5.0, 6.0);
    //...
}

通过显式传递参数，编译器可以更好地进行优化，减少因默认参数带来的潜在性能损失。

性能分析与调优

在实际项目中，要确定默认参数对性能的具体影响，需要进行性能分析。可以使用性能分析工具，如 Linux 下的 perf，Windows 下的 Performance Analyzer 等，来分析函数的调用次数、执行时间以及代码体积等指标。通过性能分析，可以确定哪些函数的默认参数使用对性能影响较大，进而针对性地进行优化。

例如，通过 perf 工具分析发现某个带有默认参数的函数在性能关键路径上被频繁调用，且占用了较多的 CPU 时间。此时，可以按照前面提到的优化策略对该函数进行调整，然后再次进行性能分析，对比优化前后的性能指标，确保优化措施确实提高了性能。

默认参数与代码维护和可读性

默认参数对代码维护的影响

默认参数在一定程度上会增加代码维护的难度。当函数的默认参数发生变化时，可能会影响到所有调用该函数且未显式传递该参数的地方。例如，有一个函数用于发送网络请求：

void sendRequest(const char* url, int timeout = 5) {
    // 发送网络请求的逻辑
    //...
}

如果在项目开发过程中，需要将 timeout 的默认值从 5 秒改为 10 秒，那么所有调用 sendRequest 且未指定 timeout 参数的代码都需要重新检查和测试，以确保新的默认值不会对程序的功能产生负面影响。

此外，当函数的默认参数依赖于其他全局变量或常量时，这些变量或常量的变化也可能影响函数的行为，增加了维护的复杂性。例如：

const int defaultBufferSize = 1024;

void processData(const char* data, int bufferSize = defaultBufferSize) {
    // 处理数据的逻辑
    //...
}

如果 defaultBufferSize 的值发生变化，processData 函数的行为可能会改变，调用该函数的代码都需要重新评估。

对代码可读性的影响

默认参数也可能对代码的可读性产生影响。如果函数的默认参数过多，或者默认参数的含义不明确，会使函数的调用者难以理解函数的行为。例如：

void configureSystem(int param1 = 1, bool flag1 = false, double param2 = 3.14, int param3 = -1) {
    // 配置系统的逻辑
    //...
}

在上述函数中，有多个默认参数，调用者在看到 configureSystem() 这样的调用时，很难直观地了解每个参数的含义和作用。这就需要通过详细的文档来解释每个默认参数的用途，但即使有文档，也不如一个参数列表清晰明了的函数容易理解。

提高代码维护性和可读性的方法

为了提高代码的维护性和可读性，对于默认参数的使用要谨慎。首先，尽量减少默认参数的数量，只保留那些真正常用且含义明确的默认参数。例如，对于上述 configureSystem 函数，可以将一些不常用的参数改为必选参数，或者通过其他方式来配置系统，而不是依赖过多的默认参数。

其次，要对默认参数进行清晰的文档说明。在函数声明或定义处，使用注释详细说明每个默认参数的含义、用途以及可能的取值范围。例如：

// @param param1 系统配置参数 1，默认值为 1，通常用于控制某种模式
// @param flag1 标志位，默认值为 false，用于启用或禁用某个功能
// @param param2 系统配置参数 2，默认值为 3.14，与某些数值计算相关
// @param param3 系统配置参数 3，默认值为 -1，用于特定的初始化
void configureSystem(int param1 = 1, bool flag1 = false, double param2 = 3.14, int param3 = -1) {
    // 配置系统的逻辑
    //...
}

通过清晰的文档说明，即使函数有默认参数，调用者也能更容易理解函数的行为，从而提高代码的可读性和维护性。

默认参数与代码可测试性

默认参数对单元测试的挑战

在进行单元测试时，默认参数可能会带来一些挑战。由于默认参数的存在，函数的调用方式变得多样，这就需要在单元测试中覆盖更多的测试用例。例如，对于一个简单的数学计算函数：

int addNumbers(int a, int b = 1) {
    return a + b;
}

在单元测试中，不仅要测试传递不同值的 a 和 b 的情况，还要测试只传递 a 参数，使用默认值 b = 1 的情况。这增加了测试用例的数量和复杂度。

此外，如果默认参数依赖于全局变量或其他外部状态，单元测试的编写会更加困难。例如：

int globalFactor = 2;

int multiplyNumbers(int a, int factor = globalFactor) {
    return a * factor;
}

在对 multiplyNumbers 函数进行单元测试时，由于默认参数 factor 依赖于全局变量 globalFactor，测试环境需要模拟不同的 globalFactor 值，以确保函数在各种情况下的正确性。这不仅增加了测试代码的复杂性，还可能导致测试结果受到全局状态的干扰。

提高代码可测试性的方法

为了提高代码的可测试性，对于依赖默认参数的函数，可以采用以下方法。一种方法是将默认参数的处理逻辑提取到一个单独的函数中。例如，对于上述 multiplyNumbers 函数，可以改为：

int multiplyNumbers(int a, int factor) {
    return a * factor;
}

int multiplyNumbersWithDefault(int a) {
    int globalFactor = 2;
    return multiplyNumbers(a, globalFactor);
}

在这种情况下，multiplyNumbers 函数没有默认参数，更容易进行单元测试。而 multiplyNumbersWithDefault 函数调用 multiplyNumbers 并使用默认值，这样在测试 multiplyNumbersWithDefault 时，只需要测试它是否正确调用了 multiplyNumbers 函数即可。

另一种方法是使用依赖注入。例如：

int multiplyNumbers(int a, int factor) {
    return a * factor;
}

class Calculator {
private:
    int factor;
public:
    Calculator(int f) : factor(f) {}
    int multiply(int a) {
        return multiplyNumbers(a, factor);
    }
};

通过依赖注入，将默认参数的值通过构造函数传递给类，在单元测试中可以方便地控制 factor 的值，从而对 multiply 函数进行全面的测试。这样，代码的可测试性得到了显著提高。

测试框架的支持

一些测试框架提供了对处理默认参数的支持。例如，Google Test 框架允许在测试用例中灵活地设置函数的参数，包括默认参数。通过使用测试框架的功能，可以更方便地编写针对带有默认参数函数的单元测试。例如：

#include "gtest/gtest.h"

int addNumbers(int a, int b = 1) {
    return a + b;
}

TEST(AddNumbersTest, WithDefaultParameter) {
    EXPECT_EQ(addNumbers(5), 6);
}

TEST(AddNumbersTest, WithCustomParameter) {
    EXPECT_EQ(addNumbers(5, 3), 8);
}

在上述代码中，使用 Google Test 框架编写了两个测试用例，分别测试了使用默认参数和自定义参数的情况。通过合理使用测试框架，可以有效地应对默认参数对单元测试带来的挑战，提高代码的可测试性。