1. 项目概述：为什么C++默认参数和引用传递值得深究？

在C++的日常开发里，我们每天都在和函数打交道。函数签名设计得好不好，直接关系到代码的易用性、效率和安全性。最近在带新人做项目时，我发现一个挺普遍的现象：很多朋友对默认参数和引用传递这两个基础特性，要么是“知其然不知其所以然”，要么就是混着用，埋下了一些不易察觉的坑。比如，为了图省事，给一个打算修改传入对象的函数参数同时设置了默认值和引用，结果编译没问题，运行时逻辑却乱了套。

这让我觉得有必要把这两块内容揉碎了讲清楚。默认参数让你在调用函数时可以少写几个参数，让接口更简洁；而引用传递则关乎性能（避免拷贝）和语义（是否修改原对象）。它们单独看都不难，但一旦组合使用，或者在一些特定场景下（比如重载、模板、继承），规则就变得微妙起来。理解背后的编译原理和最佳实践，能让你写出更健壮、更地道的C++代码。这篇文章，我就从一个老码农的角度，结合实例和踩过的坑，来聊聊它们的语法、核心用法以及那些容易翻车的细节。

2. 默认参数：让函数调用更灵活的“语法糖”

默认参数，顾名思义，就是在函数声明或定义时，给某些参数指定一个默认值。这样在调用函数时，如果调用者没有为这些参数提供实参，编译器就会自动使用我们预设的默认值。

2.1 基本语法与声明规则

在C++中，默认参数的指定非常直观。你只需要在函数声明（通常在头文件中）的参数列表中，使用等号（=）为参数赋值即可。

// 函数声明中指定默认参数 void printMessage(const std::string& msg, int times = 1, char separator = '\n');

这里，times和separator都有默认值。调用时，你可以有多种选择：

printMessage("Hello"); // 使用 times=1, separator='\n' printMessage("Hello", 3); // 使用 times=3, separator='\n' printMessage("Hello", 3, ' '); // 使用 times=3, separator=' '

关于声明位置，有一条黄金法则：默认参数只能在函数声明中指定一次，通常是在头文件的函数声明中，而不是在函数定义处。如果同时在声明和定义处指定，即使值相同，大多数编译器也会报错（重复定义）。将默认参数放在声明处，确保了所有包含该头文件的编译单元都看到一致的接口。

另一个关键规则是默认参数的“右倾”原则：一旦某个参数被赋予了默认值，它右边的所有参数都必须有默认值。你不能“跳跃”着设置。

// 正确：默认参数从右向左连续 void func(int a, int b = 5, int c = 10); // OK void func(int a, int b, int c = 10); // OK，只有最右边的有默认值 // 错误：默认参数不连续 void func(int a = 1, int b, int c); // 错误！a有默认值，但b没有 void func(int a, int b = 2, int c); // 错误！b有默认值，但右边的c没有

这么设计主要是为了函数调用的解析能无歧义。编译器需要根据你传入实参的位置来判断哪个实参对应哪个形参。如果中间某个参数没有默认值，编译器就无法判断你传入的第二个实参是想给b还是想跳过b给c。

2.2 默认参数的值与求值时机

默认值可以是任何表达式，包括常量、全局变量、函数调用，甚至其他参数（但必须是该参数左侧的参数）。但这里有个非常重要的细节：默认参数的求值发生在函数被调用时，而不是在函数声明或定义时。

int defaultVal() { static int count = 0; return ++count; } void demo(int x = defaultVal()) { std::cout << x << std::endl; } int main() { demo(); // 输出 1 demo(); // 输出 2 demo(100); // 输出 100，不使用默认值 return 0; }

每次调用demo()而不提供参数时，都会执行一次defaultVal()函数。这意味着默认参数表达式可以是动态的。但这也带来了一个潜在风险：如果默认参数表达式有副作用（比如修改了全局状态），或者执行成本很高，就需要谨慎使用。

注意：默认参数的值在函数声明处确定后，对调用者就是可见的。如果修改了默认值（比如将times = 1改成times = 2），那么所有包含该声明的源文件都需要重新编译，否则可能导致未定义行为，因为调用者可能还在使用旧的默认值进行函数调用。

2.3 默认参数与函数重载的交互

当默认参数遇上函数重载，情况会变得有趣，也可能让人困惑。编译器会尝试找到最匹配的函数版本。

void overloaded(int x) { std::cout << "int: " << x << std::endl; } void overloaded(int x, int y = 10) { std::cout << "int, int: " << x << ", " << y << std::endl; } int main() { overloaded(5); // 歧义错误！两个函数都匹配。 return 0; }

对于调用overloaded(5)，第一个函数完全匹配。第二个函数因为第二个参数有默认值，也可以被调用为overloaded(5, 10)，因此也匹配。这就产生了二义性，编译器无法决定该用哪个，所以会报错。

避坑指南：在设计重载函数时，要尽量避免让一个带有默认参数的函数版本，在参数数量上“覆盖”另一个无默认参数的版本。这通常意味着重载函数应该在参数类型上有所不同，而不仅仅是参数数量加默认参数的组合。

2.4 在类与继承中的使用

在类成员函数中，默认参数同样适用，并且可以给this指针指向的成员变量赋值作为默认值。

class Printer { public: // 默认使用成员变量作为打印前缀 void print(const std::string& text, const std::string& prefix = m_defaultPrefix) const { std::cout << prefix << text << std::endl; } void setDefaultPrefix(const std::string& prefix) { m_defaultPrefix = prefix; } private: std::string m_defaultPrefix = "Info: "; };

这里有一个关键点：默认参数m_defaultPrefix是Printer类的一个成员变量。这是允许的，因为默认参数在调用点求值，此时对象已经存在，可以访问其成员。

在继承体系中，默认参数的处理需要特别小心。默认参数是静态绑定的，而虚函数是动态绑定的。这句话有点绕，看例子：

class Base { public: virtual void show(int x = 10) const { std::cout << "Base::show, x = " << x << std::endl; } }; class Derived : public Base { public: virtual void show(int x = 20) const override { // 注意：这里重新指定了默认值 std::cout << "Derived::show, x = " << x << std::endl; } }; int main() { Base* ptr = new Derived(); ptr->show(); // 输出什么？ delete ptr; return 0; }

输出结果是：Derived::show, x = 10。 是不是有点意外？函数体执行的是Derived版本的show（动态绑定），但默认参数x的值却用的是Base中声明的10（静态绑定）。因为默认参数的值是在编译时，根据调用表达式的静态类型（此处是Base*）来确定的。所以，在派生类中重新定义虚函数时，最好不要改变默认参数的值，否则会引发非常令人困惑的行为。好的实践是只在基类中指定默认参数，派生类继承并使用它。

3. 引用传递：性能与语义的双重考量

说完了默认参数，我们再来啃另一块硬骨头：引用传递。C++中函数参数传递主要有三种方式：传值、传指针、传引用。引用传递结合了传值的简洁语法和传指针的高效，成为了现代C++中非常推荐的方式。

3.1 引用传递的核心优势：避免不必要的拷贝

这是引用传递最直接、最重要的好处。当你需要向函数传递一个大的对象（比如std::vector,std::string, 自定义类）时，传值会导致整个对象被复制一份，成本很高。

// 传值：低效 void processByValue(std::vector<int> data) { // 修改data不影响原vec data.push_back(99); } // 传引用：高效 void processByReference(std::vector<int>& data) { // 修改data直接影响原vec data.push_back(99); } int main() { std::vector<int> bigVec(1000000, 1); // 一个包含100万个元素的向量 processByValue(bigVec); // 糟糕！发生100万个int的拷贝！ processByReference(bigVec); // 优秀！只传递了一个“别名”，无拷贝。 return 0; }

对于内置类型（int,double等）或小型结构体，传值的开销很小，有时甚至比传引用更快（因为引用底层可能是指针实现，有间接寻址开销）。但对于大多数自定义类型和标准库容器，传引用是更优选择。

3.2 常量引用：只读访问的保障

如果我们不希望函数内部修改传入的对象，就应该使用常量引用（const T&）。这既保证了效率（无拷贝），又保证了安全性（对象只读）。

// 好的设计：使用常量引用传递只读参数 double calculateAverage(const std::vector<double>& values) { if (values.empty()) return 0.0; double sum = 0.0; for (double val : values) { // 范围for循环，val是值的拷贝，安全 sum += val; } return sum / values.size(); } // 调用者可以放心传递任何vector，不用担心被修改。

重要原则：对于函数内部不需要修改的输入参数，优先使用const T&。这是C++社区广泛接受的约定，能让代码意图更清晰。

3.3 非常量引用：明确表达修改意图

当函数需要修改其参数时，就使用非常量引用（T&）。这相当于向调用者明确声明：“我会改变你传进来的这个东西。”

void normalizeVector(std::vector<double>& vec) { double norm = 0.0; for (double val : vec) norm += val * val; norm = std::sqrt(norm); if (norm > 0) { for (double& val : vec) val /= norm; // 注意这里是对vec元素的引用 } } // 调用者知道，传入的vector内容会被改变。

使用非常量引用，而不是指针，可以让语法更干净（不需要取地址&和解引用*），也减少了指针为nullptr的风险。当然，引用必须绑定到一个已存在的对象，不能为空。

3.4 右值引用与移动语义：性能的终极优化

C++11引入了右值引用（T&&），主要用于实现移动语义和完美转发。它允许我们“窃取”临时对象（右值）的资源，从而避免深拷贝。

class BigData { // ... 假设有大量堆内存数据 }; void processData(const BigData& data) { /* 只读 */ } void processData(BigData&& data) { /* 可以“移动”data的资源 */ } int main() { BigData data1; processData(data1); // 调用第一个版本，常量引用 processData(BigData()); // 调用第二个版本，右值引用，可以高效移动 processData(std::move(data1)); // 调用第二个版本，将左值转为右值引用 // 注意：此后data1处于有效但未定义的状态，不应再使用其值。 return 0; }

对于函数参数设计，如果一个函数需要“接管”一个对象的所有权（比如构造函数、赋值运算符、push_back），提供右值引用版本可以极大提升性能。标准库的很多容器（如std::vector::push_back）都利用了这一点。

4. 当默认参数遇上引用传递：组合使用的陷阱与最佳实践

单独使用两者都不算复杂，但把它们组合在一起时，一些隐藏的规则和陷阱就浮现出来了。这是最能体现一个C++程序员功底的地方之一。

4.1 基本组合与语法

从语法上讲，给引用类型的参数设置默认值是允许的。

void configureLogger(const std::string& logLevel = "INFO", std::ostream& outputStream = std::cout) { // ... 配置日志级别和输出流 }

这里，logLevel是一个常量字符串引用，默认绑定到字符串字面量"INFO"。outputStream是一个非常量引用，默认绑定到标准输出std::cout。

4.2 默认参数绑定到临时对象的危险

这是第一个大坑。默认参数在每次调用时求值并绑定。对于引用类型，必须确保默认值是一个可以绑定的左值，并且其生命周期要长于函数调用。

const std::string& getDefaultName() { return "DefaultName"; // 错误！返回了局部临时对象的引用 } void badExample(const std::string& name = getDefaultName()) { // 危险！ std::cout << name << std::endl; // 可能访问已销毁的内存 }

函数getDefaultName返回了一个对临时字符串字面量（转换为std::string临时对象）的常量引用。当函数调用结束时，这个临时对象就被销毁了。而badExample的默认参数在调用点求值，得到了一个“悬垂引用”（dangling reference），后续在函数体内使用name会导致未定义行为。

安全做法：确保默认参数绑定到具有静态存储期的对象。

const std::string& getDefaultNameSafe() { static const std::string s_defaultName = "DefaultName"; // 静态存储期 return s_defaultName; } void goodExample(const std::string& name = getDefaultNameSafe()) { // 安全 std::cout << name << std::endl; }

或者直接使用字符串字面量（对于const char*或std::string类型，有特殊规则保证其存在）：

void anotherGoodExample(const std::string& name = "DefaultName") { // 也安全 std::cout << name << std::endl; }

对于std::string参数，用字符串字面量作为默认值，会构造一个临时的std::string对象，并将其绑定到常量引用。这个临时对象的生命周期会持续到创建它的完整表达式结束（即函数调用表达式结束），因此在函数体内使用是安全的。这是C++标准的一条特殊规则。

4.3 非常量引用参数的默认值限制

对于非常量引用（T&），限制就更严格了。非常量引用不能绑定到临时对象、字面量或需要类型转换的表达式。因此，为其设置默认值的选择非常有限。

// 错误示例 void increment(int& x = 0) { // 编译错误！非常量引用不能绑定到字面量0 ++x; } void printToStream(std::ostream& os = std::cout) { // 正确！std::cout是左值 os << "Hello\n"; } // 一个常见的技巧：使用静态变量 int& getDefaultCounter() { static int counter = 0; // 静态左值 return counter; } void incrementSafe(int& x = getDefaultCounter()) { // 正确 ++x; }

所以，当你看到一个函数的参数是非常量引用并且有默认值时，这个默认值几乎总是一个全局或静态的左值对象。

4.4 在重载解析中的复杂情况

当多个重载函数都使用了默认参数和引用时，重载解析会变得极其复杂，容易产生二义性。

void ambiguous(int x) { std::cout << "by value\n"; } void ambiguous(const int& x) { std::cout << "by const ref\n"; } int main() { int a = 5; ambiguous(a); // 歧义！两个函数都完美匹配。 ambiguous(10); // 歧义！字面量10可以绑定到const int&，也可以用于初始化int。 return 0; }

对于调用ambiguous(a)，a是左值。第一个版本需要一次拷贝（传值），第二个版本是精确匹配（左值可以绑定到常量引用）。根据重载决议规则，两者都需要一次转换（一个是左值到右值的转换，一个是限定性转换），等级相同，产生歧义。对于ambiguous(10)，10是右值。同样，两个版本都需要转换，产生歧义。

最佳实践：避免设计这种仅在“传值”和“传常量引用”上有区别的重载函数。它们的用途几乎完全相同，却会引入不必要的复杂性。通常，对于内置类型或小型可拷贝类型，直接传值；对于大型或不可拷贝类型，使用常量引用。不要同时提供两个版本。

5. 实战：设计清晰且安全的函数接口

理论说再多，不如看几个实际的例子。我们来设计几个函数，看看如何综合运用默认参数和引用传递。

5.1 示例一：一个灵活的字符串处理函数

假设我们要写一个函数，将字符串中的字母全部转为大写，可以指定是否只转换第一个字母。

#include <string> #include <cctype> // for std::toupper #include <algorithm> // 参数说明： // str: 待处理的字符串，函数需要修改它，所以是非常量引用。 // firstOnly: 是否只转换第一个字母，默认为false（转换全部）。 void toUpperCase(std::string& str, bool firstOnly = false) { if (str.empty()) return; if (firstOnly) { // 只转换第一个字母 str[0] = static_cast<char>(std::toupper(static_cast<unsigned char>(str[0]))); // 注意：std::toupper 的参数和返回值是 int，且需要转换为 unsigned char 以避免负值问题。 } else { // 转换全部字母 std::transform(str.begin(), str.end(), str.begin(), [](unsigned char c) { return std::toupper(c); }); } } int main() { std::string text1 = "hello world"; std::string text2 = "hello world"; toUpperCase(text1); // 默认转换全部 std::cout << text1 << std::endl; // 输出 "HELLO WORLD" toUpperCase(text2, true); // 只转换第一个 std::cout << text2 << std::endl; // 输出 "Hello world" return 0; }

设计要点：

1. 非常量引用std::string&：明确告知调用者，函数会修改传入的字符串。
2. 默认参数bool firstOnly = false：提供了最常见的用例（转换全部）的简洁调用方式，同时保留了灵活性。
3. 注意字符处理安全：直接使用std::toupper(char)在某些区域设置下对于负值字符（如扩展ASCII）是未定义行为。安全的做法是先转换为unsigned char。

5.2 示例二：带默认配置的初始化函数

考虑一个初始化网络连接的函数，有很多配置项，但大部分情况下使用默认配置即可。

struct ConnectionConfig { std::string host = "localhost"; int port = 8080; int timeoutMs = 5000; bool useSsl = false; // ... 其他配置 }; class NetworkConnection { public: // 使用默认配置初始化 bool init() { return init(ConnectionConfig{}); } // 使用提供的配置初始化 bool init(const ConnectionConfig& config) { // 使用常量引用，避免拷贝 // ... 具体的初始化逻辑，使用config.host, config.port等 std::cout << "Connecting to " << config.host << ":" << config.port << " (timeout: " << config.timeoutMs << "ms)" << std::endl; // 模拟连接成功 return true; } // 或者，使用单个参数带默认值的方式（当参数较少时） bool connect(const std::string& host = "localhost", int port = 8080, int timeoutMs = 5000) { ConnectionConfig cfg; cfg.host = host; cfg.port = port; cfg.timeoutMs = timeoutMs; return init(cfg); } };

设计要点：

1. 使用结构体封装多个配置：当参数超过3-4个时，使用结构体（或类）比一长串默认参数更清晰，也更容易扩展。
2. 提供重载的init函数：一个无参版本内部调用有参版本并传入默认构造的ConnectionConfig。这样调用者既可以使用全默认配置（conn.init()），也可以精细控制（conn.init(myConfig)）。
3. 参数传递使用const ConnectionConfig&：因为ConnectionConfig可能包含字符串等成员，传值拷贝成本高，传常量引用是高效且安全的选择。
4. 备选方案connect函数：展示了当参数较少且语义明确时，直接使用默认参数也是一种简洁的API设计。

5.3 示例三：需要返回多个值的函数

有时函数需要修改多个传入的参数。虽然现代C++更推荐使用返回值（如std::tuple或自定义结构体），但通过引用参数返回多个值仍是常见模式。

#include <tuple> #include <cmath> // for std::sin, std::cos // 方法1：使用引用参数（传统C风格） void calculatePolarToCartesian(double radius, double angle, double& outX, double& outY) { outX = radius * std::cos(angle); outY = radius * std::sin(angle); } // 方法2：使用std::pair或std::tuple返回（现代C++风格） std::pair<double, double> calculatePolarToCartesianModern(double radius, double angle) { return {radius * std::cos(angle), radius * std::sin(angle)}; } // 方法3：结合默认参数和引用参数（一个参数输入，一个参数输出） bool parseInteger(const std::string& str, int& outValue, int base = 10) { try { size_t pos; outValue = std::stoi(str, &pos, base); // 检查是否整个字符串都被解析了 return pos == str.length(); } catch (const std::invalid_argument&) { return false; } catch (const std::out_of_range&) { return false; } } int main() { // 使用方法1 double x1, y1; calculatePolarToCartesian(5.0, 0.785, x1, y1); // 必须传入变量 // 使用方法2 (C++17 结构化绑定) auto [x2, y2] = calculatePolarToCartesianModern(5.0, 0.785); // 使用方法3 int value; bool success = parseInteger("42", value); // 使用默认十进制 bool successHex = parseInteger("2A", value, 16); // 指定十六进制 return 0; }

设计要点：

1. 输出参数：像calculatePolarToCartesian中的outX和outY，是非常量引用，用于将计算结果“返回”给调用者。函数名或文档必须明确说明哪些参数是输入，哪些是输出。
2. 默认参数与输出参数结合：如parseInteger函数，str是输入（常量引用），outValue是输出（非常量引用），base是带有默认值的输入参数。这种组合很常见。
3. 现代替代方案：在C++11之后，更推荐使用方法2，使用std::tuple或自定义结构体作为返回值，代码更清晰，并且支持C++17的结构化绑定，使用起来非常方便。输出参数模式在需要返回多个值且无法使用返回值时（比如某些操作符重载）仍有其用武之地。

6. 进阶话题与性能考量

掌握了基础用法后，我们再看一些更深入的话题，它们会影响代码的性能和正确性。

6.1 默认参数与内联函数

内联函数（inline）和默认参数通常可以很好地协同工作。默认参数信息在调用点展开，内联函数体也在调用点展开，两者没有冲突。

// 头文件 inline_utils.h #ifndef INLINE_UTILS_H #define INLINE_UTILS_H inline int incrementWithDefault(int x, int step = 1) { return x + step; } #endif

但是，有一个重要细节：默认参数是函数接口的一部分。如果一个内联函数在多个编译单元（.cpp文件）中被定义（因为头文件被多次包含），那么它的默认参数必须在所有定义中保持一致，否则违反单一定义规则（ODR），导致未定义行为。所以将默认参数和内联函数一起放在头文件中是标准做法。

6.2 引用传递与const正确性

const正确性是C++编程的基石。对于引用参数，const的使用至关重要。

• const T&：承诺不修改对象，可以接受常量对象、非常量对象、临时对象。
• T&：承诺要修改对象，只能接受非常量左值对象。

不要滥用非常量引用。如果一个函数逻辑上不应该修改某个参数，即使技术上可以（因为传入的是非常量对象），也应该将其声明为const T&。这既是自我约束，也让代码的读者和编译器更容易理解你的意图。

// 不良设计：参数应该是只读的，却用了非常量引用 int computeLength(std::string& str) { // 糟糕！函数名暗示是计算，但参数却可修改 return str.length(); } // 良好设计：使用常量引用 int computeLengthGood(const std::string& str) { // 清晰，安全 return str.length(); }

6.3 移动语义对函数参数设计的影响

C++11的移动语义改变了我们设计函数参数的习惯。对于“接收参数并存储”的函数（如setter、构造函数），现在有了新的最佳实践。

传统方式（拷贝）：

class Widget { std::string m_name; public: void setName(const std::string& name) { m_name = name; } // 拷贝赋值 };

现代方式（拷贝/移动）：

class Widget { std::string m_name; public: // 按值传递，然后在内部使用std::move void setName(std::string name) { m_name = std::move(name); } };

第二种方式被称为“按值传递并移动”。对于左值调用（setName(str)），会发生一次拷贝构造（到参数name）和一次移动赋值（到m_name）。对于右值调用（setName(getName())），会发生一次移动构造和一次移动赋值。在很多情况下，这比传统的“常量引用+拷贝”性能更好或相当，而且代码更简洁。但这并非绝对，对于小型可拷贝类型（如int,double），直接传值可能更优；对于需要重载多个版本（如const T&和T&&）的复杂情况，按值传递可能简化代码。需要根据具体类型和场景权衡。

6.4 函数指针与成员函数指针中的默认参数

这是一个比较冷门但可能踩坑的点。默认参数的信息与函数指针类型本身无关，而是在调用函数指针时，根据该指针当时所指向的具体函数来决定。

void func(int x, int y = 10) { std::cout << x << ", " << y << std::endl; } void anotherFunc(int x, int y = 20) { std::cout << "Another: " << x << ", " << y << std::endl; } int main() { void (*fp)(int, int) = func; // 函数指针类型不包含默认参数信息 fp(5, 10); // 必须提供两个参数 // fp(5); // 错误！通过函数指针调用时，默认参数无效！ fp = anotherFunc; fp(5, 20); // 调用anotherFunc，但必须显式传20 return 0; }

通过函数指针调用函数时，不能使用默认参数。你必须提供所有参数。这是因为默认参数是函数声明的一部分，而函数指针类型只编码了参数类型和返回类型，不包含默认值信息。成员函数指针同理。

7. 常见问题、调试技巧与最佳实践总结

在实际项目中，围绕默认参数和引用传递的问题层出不穷。这里我总结了一张常见问题排查表，以及一些血泪教训换来的最佳实践。

7.1 常见问题排查速查表

7.2 调试技巧：查看编译器实际调用了哪个函数

当重载和默认参数导致困惑时，可以让编译器告诉我们它选择了哪个函数。

1. 使用IDE的提示：现代IDE（如CLion, Visual Studio）在鼠标悬停或代码补全时，会显示函数签名，包括默认参数。
2. 编译器诊断：GCC/Clang可以使用-Woverloaded-virtual警告来提示虚函数隐藏问题。使用-fsyntax-only和-Werror可以帮助严格检查。
3. “蠢办法”调试：在重载函数的函数体内添加不同的打印语句，运行程序看输出哪个。
4. 静态分析工具：像Clang-Tidy这样的工具可以检测出许多与默认参数和引用相关的潜在问题，如bugprone-easily-swappable-parameters（当参数类型相同且带有默认值时容易误用）。

7.3 最佳实践清单

根据我多年的经验，我总结了以下几条关于默认参数和引用传递的“军规”，遵守它们能避免绝大多数问题：

1. 默认参数声明一处：始终在头文件的函数声明中指定默认参数，不要在定义处重复指定。
2. 默认参数右倾：从右向左连续设置默认参数，不要跳跃。
3. 引用默认值需长寿：确保引用类型参数的默认值是一个生命周期足够长的左值。警惕返回临时对象引用的函数。
4. const引用是首选：对于函数内部不修改的输入参数，优先使用const T&。这安全、高效、意图明确。
5. 非常量引用表意图：使用T&明确表示函数会修改该参数。不要将其用于“可选的输出”参数，考虑使用指针（允许nullptr）或std::optional<T&>（C++23）。
6. 慎用重载与默认参数组合：避免设计仅靠默认参数数量来区分的重载函数，这极易导致歧义。用不同的参数类型或名字来区分功能。
7. 虚函数默认参数不要改：在派生类中覆盖虚函数时，不要改变默认参数的值。如果需要不同的默认行为，考虑使用不同的函数名，或通过其他设计模式实现。
8. 函数指针无视默认值：通过函数指针调用函数时，记得提供所有参数，默认参数不起作用。
9. 按值传递并移动：对于需要存储传入参数的函数（如setter），考虑使用“按值传递并std::move”的方式，这可能比传统的“常量引用+拷贝”更高效或更简洁，尤其是对于移动成本低的类型。
10. 参数过多用结构体：当函数参数超过3-4个，或者某些参数逻辑上是一组配置时，使用结构体或类来封装它们，比一长串默认参数更清晰、更易维护。

说到底，默认参数和引用传递都是工具，目的是让代码更清晰、更高效、更易用。理解它们背后的机制和约束，你就能在合适的场景下做出合适的选择，写出既优雅又健壮的C++代码。