当前位置：首页 > news >正文

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

news 2025/9/22 17:46:53

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++ 有三种主要的参数传递方式：

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

cpp

运行

void increment(int x) {x++; // 只修改形参，不影响实参
}int main() {int num = 5;increment(num);cout << num << endl; // 输出5，实参未改变return 0;
}

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

cpp

运行

void increment(int* x) {(*x)++; // 通过指针修改实参
}int main() {int num = 5;increment(&num);cout << num << endl; // 输出6，实参被修改return 0;
}

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

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=9cout << power(3, 3) << endl; // 提供实参，计算3^3=27return 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 重载的注意事项

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

cpp

运行

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

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

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 内联函数的特性

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

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 递归的基本结构

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

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

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)，输出2return 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); // 编译期计算，结果为120int arr[factorial(3)]; // 合法，编译期已知大小为6return 0;
}

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

八、函数设计最佳实践

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

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;
}