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

函数是C++程序组织与复用的核心单元，它将一段逻辑封装为可调用的命名模块，使程序具备结构化、可维护和可扩展的特性。在Qt开发中，无论是信号槽回调、事件处理还是业务逻辑封装，都离不开对函数机制的深入理解。本章将系统讲解函数的定义语法、三种参数传递方式的本质区别、返回值优化、重载与默认参数的灵活运用、内联函数的适用场景、递归的栈帧模型，以及C++作用域规则的完整体系。掌握这些内容，是写出高质量、高性能C++代码的基石。

3.1 函数定义与调用机制

核心原理：函数定义由返回类型、函数名、参数列表和函数体四部分组成。返回类型决定了函数向调用者返回的数据类型，可以是内置类型、自定义类型或 void（无返回值）。函数名遵循标识符命名规则，参数列表声明了函数所需的输入。函数体是实际执行的代码块。调用函数时，程序会将控制权转移到函数入口，执行完毕后返回调用点继续执行。

判断方法：在设计函数时，需要明确以下几个关键决策：

• 返回类型选择：如果函数需要产生结果，则返回具体类型；如果仅执行操作，则使用 void。对于大型对象，优先考虑返回引用或指针以避免不必要的拷贝。
• 参数设计：参数应尽量少而精，超过5个参数时考虑使用结构体或类进行封装。
• 函数职责：单一职责原则——每个函数只做一件事，便于测试和复用。

// 函数定义示例
int add(int a, int b) {
    return a + b;
}

void printMessage(const std::string& msg) {
    std::cout << msg << std::endl;
}

// 调用示例
int sum = add(3, 5);        // sum = 8
printMessage("Hello Qt");   // 输出 Hello Qt

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

核心原理：三种参数传递方式在内存模型和语义上有本质区别。值传递将实参的值拷贝到形参，函数内修改不影响原变量；引用传递为实参建立别名，函数内操作直接作用于原变量；指针传递拷贝实参的地址，通过解引用可以修改原变量，但指针本身是拷贝的。

操作流程：选择参数传递方式时，遵循以下决策路径：

1. 如果参数是内置类型（int、char、double等）且不需要修改原值，使用值传递。
2. 如果参数是自定义类型（类、结构体）且不需要修改，使用 const 引用传递。
3. 如果需要在函数内修改实参，使用引用传递（更安全）或指针传递（兼容C风格）。
4. 如果参数可能为空（可选参数），使用指针并检查空值。

// 值传递：不修改原值
void incrementByValue(int x) {
    x++;
}

// 引用传递：修改原值
void incrementByRef(int& x) {
    x++;
}

// 指针传递：修改原值，可空
void incrementByPtr(int* x) {
    if (x) (*x)++;
}

int main() {
    int a = 10;
    incrementByValue(a);  // a 仍为 10
    incrementByRef(a);    // a 变为 11
    incrementByPtr(&a);   // a 变为 12
    return 0;
}

3.3 返回值与返回优化

核心原理：返回值将函数计算结果传递给调用者。C++11 引入了移动语义，配合返回值优化（RVO/NRVO），可以显著减少临时对象的拷贝开销。对于大型对象，优先考虑返回局部对象（依赖RVO）或使用输出参数。

判断方法：选择返回方式时考虑以下因素：

• 返回内置类型：直接返回值，开销极小。
• 返回大型对象：优先返回局部对象（编译器自动优化），或使用移动语义。
• 返回容器或字符串：Qt中返回 QString、QList 等隐式共享类时，拷贝开销极低，可安全返回值。
• 返回多个值：使用 std::pair、std::tuple 或结构体。

// 返回大型对象（依赖RVO优化）
QString createMessage() {
    QString msg = "Hello";
    msg += " Qt";
    return msg;  // 编译器优化，无拷贝
}

// 使用输出参数
void getDimensions(int& width, int& height) {
    width = 1920;
    height = 1080;
}

3.4 函数重载与默认参数

核心原理：函数重载允许在同一作用域内定义多个同名函数，但参数列表必须不同（参数类型、个数或顺序）。编译器根据调用时实参的类型和数量选择匹配的重载版本。默认参数为函数参数提供默认值，调用时可以省略这些参数。

操作流程：设计重载函数时，遵循以下原则：

1. 重载函数应实现相似的功能，避免语义混淆。
2. 默认参数只能从右向左连续设置，不能跳跃。
3. 重载与默认参数同时使用时，需避免二义性调用。

// 函数重载
int max(int a, int b) { return a > b ? a : b; }
double max(double a, double b) { return a > b ? a : b; }
int max(int a, int b, int c) { return max(max(a, b), c); }

// 默认参数
void drawRect(int width, int height, int borderWidth = 1, bool filled = false) {
    // 绘制矩形
}

// 调用
drawRect(100, 50);                    // 使用默认参数
drawRect(100, 50, 2, true);           // 全部指定
drawRect(100, 50, 3);                 // 部分默认

3.5 内联函数与递归

核心原理：内联函数通过 inline 关键字建议编译器在调用处展开函数体，避免函数调用开销。但内联仅适用于小型函数（通常少于10行），且编译器有权忽略该建议。递归是函数直接或间接调用自身，每次调用创建新的栈帧，需要明确的终止条件。

判断方法：选择内联函数的条件：

• 函数体短小（1-5行），且被频繁调用。
• 函数不含循环、递归或复杂控制流。
• 在头文件中定义内联函数，避免链接错误。

递归设计要点：

1. 明确基准情形（终止条件），防止无限递归。
2. 每次递归调用应缩小问题规模。
3. 注意栈深度限制，过深递归可能导致栈溢出。

// 内联函数
inline int square(int x) { return x * x; }

// 递归：计算阶乘
int factorial(int n) {
    if (n <= 1) return 1;  // 基准情形
    return n * factorial(n - 1);  // 递归调用
}

// 递归：计算斐波那契数列
int fibonacci(int n) {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

void findCppFiles(const QDir& dir, QStringList& result) {
    const auto files = dir.entryList(QDir::Files);
    for (const auto& file : files) {
        if (file.endsWith(".cpp")) {
            result.append(dir.filePath(file));
        }
    }
    const auto subDirs = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
    for (const auto& subDir : subDirs) {
        findCppFiles(QDir(dir.filePath(subDir)), result);
    }
}

3.6 作用域规则详解

核心原理：作用域定义了变量、函数和类型的可见范围。C++作用域分为：全局作用域、命名空间作用域、类作用域、函数作用域和块作用域。变量在作用域内可见，离开作用域后销毁（局部变量）或仍存在（全局/静态变量）。

操作流程：变量查找遵循“由内向外”的遮蔽规则：

1. 先在当前块作用域查找。
2. 逐层向外查找外层块、函数、类、命名空间。
3. 最后查找全局作用域。
4. 使用 :: 前缀强制访问全局变量。

#include <iostream>

int globalVar = 100;  // 全局作用域

namespace MySpace {
    int value = 200;  // 命名空间作用域
}

void func() {
    int localVar = 300;  // 函数作用域
    {
        int blockVar = 400;  // 块作用域
        std::cout << blockVar;  // 输出 400
    }
    // blockVar 在此不可见
    std::cout << localVar;  // 输出 300
}

int main() {
    int globalVar = 50;  // 遮蔽全局变量
    std::cout << globalVar;      // 输出 50（局部）
    std::cout << ::globalVar;    // 输出 100（全局）
    std::cout << MySpace::value; // 输出 200
    return 0;
}

3.7 综合案例：Qt计算器核心逻辑

案例背景：开发一个简易计算器，需要支持加减乘除四则运算，并处理连续运算和错误输入。要求代码结构清晰、易于扩展。

初始目标：实现一个 Calculator 类，包含运算函数、历史记录和错误处理。

关键设计：

class Calculator {
public:
    // 重载：支持不同类型运算
    double calculate(double a, double b, char op);
    int calculate(int a, int b, char op);
    
    // 默认参数：精度可选
    QString formatResult(double value, int precision = 2);
    
    // 引用传递：输出结果和错误码
    bool safeCalculate(double a, double b, char op, double& result, QString& error);
    
private:
    // 内联函数：快速判断操作符
    inline bool isValidOp(char op) {
        return op == '+' || op == '-' || op == '*' || op == '/';
    }
    
    // 递归：计算表达式（简化版）
    double evaluateExpression(const QString& expr, int& pos);
};

// 实现
double Calculator::calculate(double a, double b, char op) {
    switch(op) {
        case '+': return a + b;
        case '-': return a - b;
        case '*': return a * b;
        case '/': 
            if (b == 0) throw std::runtime_error("Division by zero");
            return a / b;
        default: throw std::invalid_argument("Invalid operator");
    }
}

bool Calculator::safeCalculate(double a, double b, char op, double& result, QString& error) {
    if (!isValidOp(op)) {
        error = "无效操作符";
        return false;
    }
    if (op == '/' && b == 0) {
        error = "除数不能为零";
        return false;
    }
    result = calculate(a, b, op);
    return true;
}

分析过程：该案例综合运用了本章所有知识点：

• 函数重载：calculate 支持 double 和 int 类型，自动匹配。
• 默认参数：formatResult 的精度参数有默认值，调用灵活。
• 引用传递：safeCalculate 通过引用返回结果和错误信息，避免多返回值。
• 内联函数：isValidOp 短小且频繁调用，内联提升性能。
• 作用域：成员变量和函数在类作用域内，局部变量在函数作用域内。

结果对比：使用 safeCalculate 后，调用方无需捕获异常，通过返回值判断成功与否，代码更健壮。递归的 evaluateExpression 可处理嵌套括号表达式，但需注意栈深度限制。

复盘经验：在实际Qt项目中，函数设计应优先考虑：参数传递方式影响性能和安全性；重载和默认参数提升API易用性；内联函数优化高频调用路径；递归需权衡可读性与栈开销。作用域规则是避免命名冲突和资源泄漏的基础。