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=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 重载的注意事项
- 返回类型不同不能作为重载的依据：
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)，输出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函数的限制，允许包含更多类型的语句。
八、函数设计最佳实践
- 单一职责原则：一个函数应只做一件事，保持函数简短精悍
- 函数命名：使用有意义的名称，清晰表达函数功能
- 参数数量：尽量减少参数数量，过多参数可考虑封装为结构体
- 避免副作用：函数应尽量只通过返回值与外部交互，减少对全局变量的修改
- 错误处理：明确函数可能的错误情况，并提供清晰的错误处理机制
- 文档注释：为函数添加注释，说明功能、参数含义、返回值和使用注意事项
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++ 标准的不断发展，函数相关的特性也在持续丰富，开发者需要不断学习以充分利用语言的新能力。
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
