4、函数与重载：函数定义、参数传递（值/引用/指针）、返回值、默认参数、函数重载、内联函数、递归

函数是C++程序组织与复用的核心单元，它将一段完成特定功能的代码封装起来，通过函数名调用，从而避免重复编写代码，提升程序的可读性、可维护性与模块化程度。本章将系统讲解函数的完整定义语法、三种参数传递方式的底层差异与适用场景、返回值的机制与陷阱、默认参数与函数重载的规则、内联函数的优化原理，以及递归的思维模型与工程限制。理解这些内容，是掌握C++面向对象编程与后续QT框架中信号槽、事件处理等机制的基础。

4.1 函数定义与返回值机制

核心原理：函数定义由返回类型、函数名、参数列表和函数体四部分组成。返回类型决定了函数向调用者返回的数据类型，可以是内置类型、自定义类型、指针或引用。当函数执行到 return 语句时，会将表达式的值拷贝（或移动）到调用栈的临时位置，然后控制权交还给调用者。对于非 void 函数，必须保证所有代码路径都有返回值，否则行为未定义。

判断方法与操作流程：设计函数时，首先明确函数的单一职责，确定输入参数和输出结果。返回值的选择遵循以下原则：

• 返回基础类型（如 int、double）时，直接按值返回，简单安全。
• 返回大型对象（如 std::string、自定义类）时，现代C++编译器会进行RVO（返回值优化）或移动语义，按值返回通常也是高效的。
• 返回指向类内部数据的指针或引用时，必须确保对象的生命周期长于调用者使用该引用的时间，否则产生悬垂引用。

案例拆解：考虑一个矩阵运算库，需要返回两个矩阵相加的结果。如果矩阵类内部使用动态数组，按值返回会触发拷贝构造，开销较大。此时可以借助移动构造函数，将临时结果的所有权转移给调用者，避免深拷贝。代码示意：

Matrix add(const Matrix& a, const Matrix& b) {
    Matrix result(a.rows(), a.cols());
    // 执行逐元素相加
    return result; // 编译器优先使用移动语义或RVO
}

常见误区：初学者容易混淆返回值和输出参数。返回值适合表达函数执行的结果状态或计算值，而输出参数（通过引用或指针）适合需要返回多个结果或修改外部变量的场景。过度使用输出参数会降低代码可读性。

4.2 参数传递：值、引用与指针

核心原理：参数传递的本质是实参到形参的初始化过程。值传递将实参的值拷贝一份给形参，函数内对形参的修改不影响实参；引用传递（T&）为实参建立别名，函数内对形参的修改直接作用于实参，且不产生拷贝；指针传递（T*）传递实参的地址，函数内通过解引用操作修改实参，但指针本身是按值传递的（即指针变量的拷贝）。

判断方法：选择参数传递方式时，遵循以下决策流程：

1. 如果参数是基础类型（int、char、double等）且不需要修改，一律使用值传递。
2. 如果参数是类对象且只读，使用 const T&。
3. 如果需要在函数内修改实参，使用 T&。
4. 如果参数可能为空或需要表达“无对象”语义，使用指针 T*。

案例拆解：实现一个交换两个整数的函数，分别用引用和指针实现：

void swap_ref(int& a, int& b) { int t = a; a = b; b = t; }
void swap_ptr(int* a, int* b) {
    if (a == nullptr || b == nullptr) return; // 指针需要判空
    int t = *a; *a = *b; *b = t;
}
// 调用
int x = 3, y = 5;
swap_ref(x, y);   // x=5, y=3
swap_ptr(&x, &y); // x=3, y=5

常见误区：引用传递时，实参必须是左值（可寻址变量），不能传递字面常量（如 swap_ref(3, 5) 编译失败）。指针传递时，忘记判空导致空指针解引用崩溃。此外，不要将引用和指针混用，保持代码风格一致。

4.3 默认参数与函数重载

核心原理：默认参数允许在函数声明时为形参指定默认值，调用时若省略该实参，则使用默认值。默认参数必须从右向左连续设置，且只能在声明或定义之一中指定（通常放在声明中）。函数重载允许在同一作用域内定义多个同名函数，但要求参数列表（参数个数、类型或顺序）不同，编译器根据调用时实参的类型和数量选择匹配的函数。

判断方法与规则：

• 默认参数：void print(std::string msg, int times = 1); 调用 print("hi") 等价于 print("hi", 1)。
• 重载匹配：编译器按“精确匹配 → 提升匹配 → 标准转换 → 用户定义转换”的顺序选择最佳函数。若存在多个匹配程度相同的函数，则产生二义性错误。
• 重载与默认参数结合时，需避免调用歧义。例如：void f(int a, int b = 10); 和 void f(int a); 同时存在时，调用 f(5) 会报二义性错误。

案例拆解：设计一个日志系统，需要支持不同级别的输出。使用默认参数和重载结合：

void log(const std::string& msg, int level = 0); // 默认级别0
void log(const std::string& msg, const std::string& tag); // 重载：带标签
// 调用
log("start");                    // 使用默认级别0
log("error", 2);                 // 级别2
log("user login", "auth");       // 调用重载版本

常见误区：重载函数时，仅返回值类型不同不能构成重载（如 int f() 和 double f() 冲突）。默认参数与重载混用时，容易产生二义性，建议优先使用重载而非默认参数来扩展功能。

4.4 内联函数与递归

核心原理：内联函数通过 inline 关键字建议编译器在调用处直接展开函数体，避免函数调用的栈帧开销（压栈、跳转、返回）。但编译器有权忽略该建议，通常适用于函数体短小（少于10行）、频繁调用的场景。递归是函数直接或间接调用自身的编程技巧，必须包含基线条件（终止条件）和递归步骤（问题规模递减），否则会无限递归导致栈溢出。

判断方法与操作流程：

• 内联函数：适合简单的getter/setter、数学计算（如平方、值）。避免在inline函数中使用循环、递归或静态变量，否则编译器可能拒绝内联。
• 递归设计：先定义基线条件（如 n == 0 时返回1），再假设子问题已解决，组合子问题的解。递归深度受限于栈大小（默认约1MB），深度超过数万层时需改用迭代。

案例拆解：计算斐波那契数列第n项，分别用递归和迭代实现，并分析性能差异：

// 递归（指数级复杂度）
int fib_rec(int n) {
    if (n <= 1) return n;
    return fib_rec(n-1) + fib_rec(n-2);
}
// 迭代（线性复杂度）
int fib_iter(int n) {
    if (n <= 1) return n;
    int a = 0, b = 1;
    for (int i = 2; i <= n; ++i) { int t = a + b; a = b; b = t; }
    return b;
}

当 n = 40 时，递归版本需要约10亿次调用，耗时数秒；迭代版本仅需40次循环。递归的优势在于代码简洁、逻辑清晰，适合树形遍历、分治算法（如快速排序、归并排序），但必须注意优化（如记忆化）和深度限制。

常见误区：内联函数定义在头文件中时，如果多个源文件包含该头文件，每个编译单元都会生成一份函数体，但链接器会合并，不会产生重定义错误。递归时忘记更新递归参数导致死循环；递归函数中定义局部大型对象，每次递归都会在栈上分配内存，加速栈溢出。

4.5 综合实战：学生成绩管理系统中的函数设计

场景与约束：开发一个控制台版学生成绩管理模块，需要支持添加学生、计算平均分、查找最高分、按学号查询等功能。系统运行在嵌入式Linux环境，内存有限（64MB），要求代码高效、可维护。

初始现象与目标：初版代码将所有逻辑写在 main() 中，导致代码冗长、无法复用。目标是将功能拆分为独立函数，并合理选择参数传递方式。

关键输入数据：学生结构体包含学号（int）、姓名（std::string）、成绩（float数组，3门课）。

分析判断过程：

1. 添加学生：需要修改学生数组，使用引用传递数组索引或指针。
2. 计算平均分：只读访问学生对象，使用 const Student& 避免拷贝。
3. 查找最高分：返回学生索引，使用值传递返回int。
4. 按学号查询：使用指针传递学生数组，返回指针或空指针表示未找到。

实际操作步骤：

struct Student { int id; std::string name; float scores[3]; };

// 添加学生（引用传递，修改数组大小）
void addStudent(std::vector<Student>& students, const Student& s) {
    students.push_back(s);
}
// 计算某学生平均分（const引用，只读）
float calcAvg(const Student& s) {
    return (s.scores[0] + s.scores[1] + s.scores[2]) / 3.0f;
}
// 查找最高分学生（返回索引，-1表示无）
int findTop(const std::vector<Student>& students) {
    if (students.empty()) return -1;
    int idx = 0;
    for (size_t i = 1; i < students.size(); ++i) {
        if (calcAvg(students[i]) > calcAvg(students[idx])) idx = i;
    }
    return idx;
}
// 按学号查询（指针返回，空指针表示未找到）
const Student* findById(const std::vector<Student>& students, int id) {
    for (const auto& s : students) {
        if (s.id == id) return &s;
    }
    return nullptr;
}

结果对比与复盘：重构后，每个函数职责单一，main() 仅负责调用和菜单显示。通过使用 const Student& 避免了每次计算平均分时的结构体拷贝（结构体含string，拷贝开销大）。使用 std::vector 管理动态数组，避免手动内存管理。风险点在于 findById 返回的指针在 vector 扩容后可能失效，因此调用方需注意不要长时间持有该指针。复盘经验：函数设计应优先考虑参数传递的const正确性，返回值尽量使用值或智能指针，避免裸指针暴露内部数据。