C++ 函数详解：从基础到高级应用

C++ 函数详解：从基础到高级应用

函数是 C++ 程序的基本构建块，是实现代码模块化、复用性和可读性的核心机制。本文将全面讲解 C++ 函数的方方面面，从基本定义到高级特性，帮助你深入理解并灵活运用函数。

一、函数的基本概念与结构

1.1 什么是函数

函数是一个完成特定任务的代码块，它接收输入（参数），执行一系列操作，并可能返回一个结果。在 C++ 中，函数可以分为：

• 标准库函数：如printf()、sqrt()等
• 自定义函数：由开发者根据需求定义

1.2 函数的基本结构

C++ 函数的基本结构如下：

cpp

运行

返回类型 函数名(参数列表) {
    // 函数体：执行操作的语句
    return 返回值; // 若返回类型为void则不需要
}

• 返回类型：函数执行完毕后返回值的类型，可以是基本类型、自定义类型，或void（表示无返回值）
• 函数名：遵循标识符命名规则，应体现函数功能
• 参数列表：函数接收的输入，由类型和变量名组成，多个参数用逗号分隔
• 函数体：包含实现函数功能的语句块
• 返回语句：将结果返回给调用者，void类型函数可以省略

1.3 函数声明与定义

函数需要先声明后使用，声明告诉编译器函数的存在和接口，定义则提供函数的实现。

cpp

运行

// 函数声明（原型）
int add(int a, int b); // 只需指定参数类型和返回类型，参数名可省略

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

函数声明通常放在头文件（.h）中，定义放在源文件（.cpp）中，这样可以实现代码的分离编译。

二、函数参数与返回值

2.1 参数传递方式

C++ 有三种主要的参数传递方式：

1. 值传递：将实参的值复制给形参，函数内部对形参的修改不影响实参

cpp

运行

void increment(int x) {
    x++; // 只修改形参，不影响实参
}

int main() {
    int num = 5;
    increment(num);
    cout << num << endl; // 输出5，实参未改变
    return 0;
}

1. 指针传递：传递实参的地址，函数内部通过指针可以修改实参的值

cpp

运行

void increment(int* x) {
    (*x)++; // 通过指针修改实参
}

int main() {
    int num = 5;
    increment(&num);
    cout << num << endl; // 输出6，实参被修改
    return 0;
}

1. 引用传递：传递实参的别名，函数内部对引用的修改直接影响实参

cpp

运行

void increment(int& x) {
    x++; // 通过引用修改实参
}

int main() {
    int num = 5;
    increment(num);
    cout << num << endl; // 输出6，实参被修改
    return 0;
}

引用传递相比指针传递更简洁安全，是 C++ 中推荐的方式。

2.2 默认参数

函数可以指定默认参数值，当调用函数时未提供对应实参，将使用默认值：

cpp

运行

// 默认参数必须从右向左定义
int power(int base, int exp = 2) {
    int result = 1;
    for (int i = 0; i < exp; i++) {
        result *= base;
    }
    return result;
}

int main() {
    cout << power(3) << endl;   // 使用默认参数，计算3^2=9
    cout << power(3, 3) << endl; // 提供实参，计算3^3=27
    return 0;
}

注意：

• 默认参数只能在函数声明中指定一次
• 默认参数必须从右向左依次定义，不能跳过某个参数指定后面的默认值

2.3 函数返回值

函数的返回值可以是任意类型，包括基本类型、指针、引用和自定义类型：

cpp

运行

// 返回基本类型
int getSum(int a, int b) {
    return a + b;
}

// 返回指针
int* createArray(int size) {
    return new int[size]; // 返回动态分配数组的指针
}

// 返回引用
int& getElement(int arr[], int index) {
    return arr[index]; // 返回数组元素的引用
}

注意：

• 不要返回局部变量的指针或引用，因为函数结束后局部变量会被销毁
• 返回引用可以作为左值使用：getElement(arr, 0) = 10;

三、函数重载

函数重载是 C++ 的多态特性之一，允许在同一作用域内定义多个同名函数，只要它们的参数列表（参数类型、数量或顺序）不同。

3.1 重载的基本形式

cpp

运行

// 重载函数：参数数量不同
int add(int a, int b) {
    return a + b;
}

int add(int a, int b, int c) {
    return a + b + c;
}

// 重载函数：参数类型不同
double add(double a, double b) {
    return a + b;
}

// 重载函数：参数顺序不同
void print(int a, double b) {
    cout << "int: " << a << ", double: " << b << endl;
}

void print(double a, int b) {
    cout << "double: " << a << ", int: " << b << endl;
}

3.2 重载决议

编译器通过分析实参的类型、数量和顺序来确定调用哪个重载函数，这个过程称为重载决议。

cpp

运行

int main() {
    add(2, 3);         // 调用add(int, int)
    add(2, 3, 4);      // 调用add(int, int, int)
    add(2.5, 3.5);     // 调用add(double, double)
    print(5, 3.14);    // 调用print(int, double)
    print(3.14, 5);    // 调用print(double, int)
    return 0;
}

3.3 重载的注意事项

1. 返回类型不同不能作为重载的依据：

cpp

运行

// 错误：仅返回类型不同不能重载
int add(int a, int b) { return a + b; }
double add(int a, int b) { return (double)(a + b); }

1. 默认参数可能导致重载二义性：

cpp

运行

// 潜在问题：调用show()时会有歧义
void show(int a = 0) { cout << a << endl; }
void show() { cout << "Default" << endl; }

四、内联函数

内联函数（inline function）是一种特殊的函数，编译器会尝试在调用处展开函数体，而不是进行常规的函数调用，从而减少函数调用的开销。

4.1 内联函数的定义

使用inline关键字声明内联函数：

cpp

运行

inline int max(int a, int b) {
    return (a > b) ? a : b;
}

4.2 内联函数的特性

1. 减少调用开销：适合小型函数，避免函数调用的栈操作、跳转等开销
2. 代码膨胀：内联会增加代码体积，大型函数不适合内联
3. 建议性质：inline只是对编译器的建议，编译器可能会忽略
4. 通常在头文件中实现：因为内联函数需要在调用处展开，需要可见其实现

4.3 内联函数与宏的区别

内联函数类似于 C 语言的宏，但更安全：

cpp

运行

// 宏定义（不安全）
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// 内联函数（安全）
inline int max(int a, int b) {
    return (a > b) ? a : b;
}

区别：

• 内联函数会进行类型检查，宏不会
• 内联函数可以调试，宏不能
• 宏可能有副作用（如MAX(a++, b++)），内联函数不会

五、递归函数

递归函数是指在函数体内调用自身的函数，适用于解决可以分解为相似子问题的问题（如阶乘、斐波那契数列、树遍历等）。

5.1 递归的基本结构

递归函数通常包含两个部分：

1. 基准情况：不需要递归就能解决的简单情况
2. 递归步骤：将问题分解为更小的子问题，并调用自身解决

cpp

运行

// 计算n的阶乘：n! = n × (n-1) × ... × 1
int factorial(int n) {
    // 基准情况
    if (n == 0 || n == 1) {
        return 1;
    }
    // 递归步骤
    return n * factorial(n - 1);
}

5.2 递归的优缺点

优点：

• 代码简洁，符合问题的自然描述
• 适合解决递归结构的问题（如树、图）

缺点：

• 可能导致栈溢出（递归深度过大时）
• 可能存在重复计算（可通过记忆化优化）

5.3 递归与迭代的转换

许多递归问题可以转换为迭代（循环）形式，避免栈溢出风险：

cpp

运行

// 迭代版本的阶乘计算
int factorialIterative(int n) {
    int result = 1;
    for (int i = 2; i <= n; i++) {
        result *= i;
    }
    return result;
}

六、函数指针

函数指针是指向函数的指针变量，可以像其他指针一样使用，支持函数的间接调用，是 C++ 中实现回调函数的基础。

6.1 函数指针的定义与使用

cpp

运行

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

// 定义函数指针类型
typedef int (*ArithmeticFunc)(int, int);

int main() {
    // 声明并初始化函数指针
    ArithmeticFunc func = add;
    
    // 使用函数指针调用函数
    cout << func(5, 3) << endl; // 调用add(5,3)，输出8
    
    // 改变函数指针指向
    func = subtract;
    cout << func(5, 3) << endl; // 调用subtract(5,3)，输出2
    
    return 0;
}

6.2 函数指针作为参数（回调函数）

函数指针常用作其他函数的参数，实现回调机制：

cpp

运行

// 回调函数：比较两个整数
bool ascending(int a, int b) { return a < b; }
bool descending(int a, int b) { return a > b; }

// 排序函数，接受回调函数指定排序方式
void sort(int arr[], int size, bool (*compare)(int, int)) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (!compare(arr[j], arr[j + 1])) {
                // 交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int numbers[] = {5, 2, 8, 1, 9};
    int size = sizeof(numbers) / sizeof(numbers[0]);
    
    // 按升序排序
    sort(numbers, size, ascending);
    
    // 按降序排序
    sort(numbers, size, descending);
    
    return 0;
}

七、C++11 及以上的函数新特性

7.1 lambda 表达式

C++11 引入了 lambda 表达式，允许在需要函数的地方直接定义匿名函数：

cpp

运行

#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9};
    
    // 使用lambda表达式作为排序的比较函数
    std::sort(numbers.begin(), numbers.end(), 
              [](int a, int b) { return a < b; }); // 升序排序
    
    // 使用lambda表达式遍历容器
    for_each(numbers.begin(), numbers.end(),
             [](int n) { cout << n << " "; });
    
    return 0;
}

lambda 表达式的基本形式：[捕获列表](参数列表) -> 返回类型 { 函数体 }

7.2 右值引用与移动语义

C++11 引入了右值引用（&&），允许函数高效地转移资源而不是复制：

cpp

运行

// 移动构造函数
class MyString {
private:
    char* data;
    int length;

public:
    // 移动构造函数
    MyString(MyString&& other) noexcept 
        : data(other.data), length(other.length) {
        // 转移资源所有权
        other.data = nullptr;
        other.length = 0;
    }
    
    // 移动赋值运算符
    MyString& operator=(MyString&& other) noexcept {
        if (this != &other) {
            delete[] data;
            // 转移资源所有权
            data = other.data;
            length = other.length;
            other.data = nullptr;
            other.length = 0;
        }
        return *this;
    }
};

7.3 constexpr 函数

C++11 引入constexpr函数，允许在编译期计算结果：

cpp

运行

// constexpr函数：可以在编译期计算
constexpr int factorial(int n) {
    return (n <= 1) ? 1 : (n * factorial(n - 1));
}

int main() {
    constexpr int result = factorial(5); // 编译期计算，结果为120
    int arr[factorial(3)]; // 合法，编译期已知大小为6
    return 0;
}

C++14 放松了对constexpr函数的限制，允许包含更多类型的语句。

八、函数设计最佳实践

1. 单一职责原则：一个函数应只做一件事，保持函数简短精悍
2. 函数命名：使用有意义的名称，清晰表达函数功能
3. 参数数量：尽量减少参数数量，过多参数可考虑封装为结构体
4. 避免副作用：函数应尽量只通过返回值与外部交互，减少对全局变量的修改
5. 错误处理：明确函数可能的错误情况，并提供清晰的错误处理机制
6. 文档注释：为函数添加注释，说明功能、参数含义、返回值和使用注意事项

cpp

运行

/**
 * 计算两个整数的最大公约数
 * @param a 第一个整数（必须为正）
 * @param b 第二个整数（必须为正）
 * @return 两个数的最大公约数
 * @throws std::invalid_argument 如果输入为非正数
 */
int gcd(int a, int b) {
    if (a <= 0 || b <= 0) {
        throw std::invalid_argument("输入必须为正数");
    }
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

九、总结

函数是 C++ 程序的核心组成部分，本文涵盖了函数的基本概念、参数传递、重载、内联函数、递归、函数指针以及 C++11 以来的新特性。掌握这些知识将帮助你编写更加模块化、高效和易维护的代码。

在实际开发中，应根据具体需求选择合适的函数特性，遵循函数设计的最佳实践，平衡代码的可读性、性能和可维护性。随着 C++ 标准的不断发展，函数相关的特性也在持续丰富，开发者需要不断学习以充分利用语言的新能力。