前置知识
作为 C++ 开发者，你是否曾在函数调用后苦恼于变量的值并没有发生预期的变化？或者在处理大型数组时，因为内存拷贝而感到性能受限？
这篇文章中，我们将深入探讨 C++ 中一个核心且强大的概念——将指针传递给函数。通过掌握这一技术，我们不仅能够直接在函数内部修改外部变量的值，还能有效提升程序处理大数据时的效率。让我们一步步揭开它的面纱，看看指针传参到底是如何工作的，以及我们如何在日常开发中高效地使用它。
为什么我们需要指针传参？
在默认情况下，C++ 中的函数参数是按值传递的。这意味着当我们将一个变量传递给函数时，实际上发生的是该变量的一份副本被创建并传递给了函数。
让我们想象一个场景：你想把一份重要的文件交给同事修改。如果你只是把文件的复印件交给他，无论他在复印件上怎么涂改，你手上的原件都不会受到影响。这就是“按值传递”的局限性。
同样的道理，在代码中，如果我们希望函数内部的操作能够真正影响外部的变量，我们就需要一种方法来传递“原件”的访问权，而不是“复印件”。这就是指针传参大显身手的时候。通过传递变量的内存地址，函数可以直接操作该内存地址上的数据，从而实现对原始数据的修改。
按值传递 vs 按指针传递
场景 1：尝试修改变量（失败案例）
首先，让我们来看一个经典的反面教材。如果我们直接传递变量，会发生什么？
// C++ program to demonstrate that passing by value
// does not modify the original variable
#include
using namespace std;
// 这个函数试图修改 x 的值
void fun(int x) {
// 这里修改的只是副本 x，main 函数中的 x 不受影响
x = 5;
}
int main()
{
int x = 9;
cout << "调用 fun 之前 x 的值: " << x << endl;
// 传递 x 的值（副本）
fun(x);
cout << "调用 fun 之后 x 的值: " << x << endl;
return 0;
}
输出：
调用 fun 之前 x 的值: 9
调用 fun 之后 x 的值: 9
代码分析：
在这个例子中，INLINECODEfc7c685b 函数中的 INLINECODE87a17a77 和 INLINECODE3735f7b1 函数中的参数 INLINECODE181e3f91 是两个完全不同的变量，它们存储在内存的不同位置。当我们调用 INLINECODEddeb7238 时，只有数值 INLINECODEdd05f8d6 被复制了过去。因此，函数内部的修改对原始数据没有任何影响。如果我们需要在函数内部“真正”改变变量的值，我们必须传递该变量的地址。
场景 2：成功修改变量（指针传参）
现在，让我们修改一下代码，使用指针来传递参数。
// C++ program to demonstrate passing a pointer to a function
// to modify the original variable
#include
using namespace std;
// 参数声明为指针类型 int*
void fun(int* ptr) {
// 解引用指针，修改指针指向的内存地址中的值
*ptr = 5;
}
int main()
{
int x = 9;
cout << "调用 fun 之前 x 的值: " << x << endl;
// 传递 x 的地址 &x
fun(&x);
cout << "调用 fun 之后 x 的值: " << x << endl;
return 0;
}
输出：
调用 fun 之前 x 的值: 9
调用 fun 之后 x 的值: 5
代码分析：
在这个改进的版本中，我们做了两个关键的改变：
- 函数参数从 INLINECODE0d87d0de 变成了 INLINECODE86de443f，告诉函数接收的是一个地址。
- 调用函数时，我们使用了 INLINECODE6bba8fca（取地址符）传递了变量 INLINECODE80663a22 的内存地址。
现在，INLINECODEa33535f6 包含了 INLINECODE1bbfb264 的地址。通过使用解引用操作符 INLINECODE6c95c7d2，我们直接访问了 INLINECODE4e7b7b0b 函数中 x 的内存位置并修改了它。这就是“原件”被修改的秘诀。
实战案例：交换两个变量的值
为了进一步巩固这个概念，让我们来看看一个非常经典的编程练习：交换两个数字。
错误示范：按值交换
如果不使用指针，我们的交换函数将毫无作用。
// C++ program to swap two values incorrectly (by value)
#include
using namespace std;
// 这里的 x 和 y 是外部变量的副本
void swap(int x, int y)
{
int temp = x;
x = y;
y = temp;
// 函数结束，副本销毁，外部变量未改变
}
int main()
{
int a = 2, b = 5;
cout << "交换前 a 和 b 的值: " << a << " " << b << endl;
swap(a, b); // 只是传递了数值
cout << "交换后 a 和 b 的值: " << a << " " << b << endl;
return 0;
}
输出：
交换前 a 和 b 的值: 2 5
交换后 a 和 b 的值: 2 5
正确示范：使用指针交换
通过传递指针，我们可以真正实现数据的交换。
// C++ program to swap two values correctly using pointers
#include
using namespace std;
void swap(int* x, int* y)
{
int temp = *x; // 取出地址 x 中的值
*x = *y; // 将地址 y 中的值赋给地址 x
*y = temp; // 将原来的 temp 值赋给地址 y
}
int main()
{
int a = 2, b = 5;
cout << "交换前 a 和 b 的值: " << a << " " << b << endl;
swap(&a, &b); // 传递 a 和 b 的地址
cout << "交换后 a 和 b 的值: " << a << " " << b << endl;
return 0;
}
输出：
交换前 a 和 b 的值: 2 5
交换后 a 和 b 的值: 5 2
关键点解析：
在这里，INLINECODEb2e10f0d 函数接收的是两个变量的地址。函数内部的操作直接针对这两个地址对应的内存空间进行，因此 INLINECODE5628984b 函数中的 INLINECODE3f183de7 和 INLINECODE34d69314 成功互换了数值。这是指针在 C++ 中最直观、最常用的应用场景之一。
进阶应用：数组与函数指针
当我们处理数组时，指针的重要性更加凸显。数组名在很多情况下会“退化为”指向其第一个元素的指针。这使得我们可以高效地将整个数组传递给函数，而不需要进行昂贵的数据拷贝。
数组在内存中是连续存储的，如果我们知道了数组的起始地址（即数组名），我们就可以通过指针算术来遍历整个数组。
示例：遍历并打印数组
下面的例子展示了如何通过传递指针来处理数组。
// C++ program to display array elements using pointers
#include
using namespace std;
// 接收一个整数指针（数组首地址）和数组长度
void display(int* ptr, int n)
{
cout << "数组元素: ";
for (int i = 0; i < n; ++i) {
// 使用指针算术访问数组元素
// *(ptr + i) 等同于 ptr[i]
cout << *(ptr + i) << " ";
}
cout << endl;
}
int main()
{
int arr[] = { 10, 20, 30, 40, 50 };
// 计算数组元素个数
int n = sizeof(arr) / sizeof(arr[0]);
// arr 代表数组首元素的地址
// 我们直接传递数组名作为指针
display(arr, n);
return 0;
}
输出：
数组元素: 10 20 30 40 50
深入理解：
在这个例子中，INLINECODE60b3f535 被传递给函数时，它自动转换为指向 INLINECODEd716b3e8 的指针。函数 INLINECODEf215ee8c 通过 INLINECODE5c62b29b 来访问后续的内存单元。这比拷贝整个数组（如果数组很大，比如包含数万个元素）要快得多，且内存开销极小。
实战扩展：修改数组内容
让我们看一个更实用的例子——将数组中的所有元素都乘以 2。
// C++ program to double the values of array elements
#include
using namespace std;
// 函数接收数组指针和大小，直接在原数组上操作
void doubleArrayValues(int* ptr, int n) {
for (int i = 0; i < n; i++) {
// 修改指针指向位置的值
*(ptr + i) *= 2;
}
}
int main() {
int numbers[] = { 1, 2, 3, 4, 5 };
int size = sizeof(numbers) / sizeof(numbers[0]);
cout << "处理前: ";
for (int i = 0; i < size; i++) cout << numbers[i] << " ";
cout << endl;
// 调用函数修改数组
doubleArrayValues(numbers, size);
cout << "处理后: ";
for (int i = 0; i < size; i++) cout << numbers[i] << " ";
cout << endl;
return 0;
}
输出：
处理前: 1 2 3 4 5
处理后: 2 4 6 8 10
这个例子展示了指针传参的另一个优势：就地修改。我们不需要创建一个新的数组来存储结果，直接在原有内存上进行操作，这在高性能计算或嵌入式开发中是非常关键的技巧。
常见陷阱与最佳实践
虽然指针非常强大，但它们也是一把“双刃剑”。在使用指针传参时，有几个关键点需要时刻牢记。
1. 避免空指针
如果函数接收指针，它应该检查指针是否为 nullptr。如果不检查就直接解引用，可能会导致程序崩溃。
void safeFunction(int* ptr) {
// 最佳实践：总是检查指针是否有效
if (ptr != nullptr) {
*ptr = 10;
} else {
cerr << "错误：接收到了空指针！" << endl;
}
}
2. 常量指针
如果你传递指针是为了读取数据，而不是为了修改它，请务必使用 const 修饰符。这是一种防守性的编程习惯，防止代码意外修改了不该修改的数据。
// const int* ptr 表示不能通过 ptr 修改它指向的值
void printValue(const int* ptr) {
// *ptr = 10; // 这行代码会导致编译错误，这正是我们想要的安全保障
cout << "值为: " << *ptr << endl;
}
3. 指针 vs 引用
作为 C++ 开发者，你可能还会遇到引用传参（Pass by Reference）。引用在语法上更简洁，不需要解引用操作符。那么什么时候用指针，什么时候用引用呢？
- 使用指针：当你需要处理“空”的情况（比如对象可以不存在），或者在进行指针算术操作（如数组遍历）时。
- 使用引用：当你确定参数一定有效，且追求代码的简洁性时。
引用示例：
// 使用引用交换
void swapRef(int& x, int& y) {
int temp = x;
x = y;
y = temp;
}
总结与后续步骤
在这篇文章中，我们深入探讨了 C++ 中将指针传递给函数的方方面面。我们从基础的按值传递的局限性出发，学习了如何通过指针来修改外部变量，实现了两个数字的交换，并进一步掌握了如何高效地处理数组数据。
掌握指针传参是通往 C++ 高级编程的必经之路。它不仅能让你更灵活地控制内存，还能帮助你理解 C++ 底层的运作机制，比如多态是如何通过虚函数表指针实现的。
接下来的学习建议：
- 尝试编写一个函数，接收一个字符串指针并反转该字符串（注意处理 ‘\0‘ 结尾）。
- 研究 C++ 标准库中 INLINECODEa60dc69e 或 INLINECODEf4ac0d8d 的迭代器，你会发现它们本质上是对指针的高级封装。
- 探索函数指针，它允许你将函数本身作为参数传递给另一个函数，这在回调机制中非常有用。
继续加油，保持对代码底层逻辑的好奇心，你会发现 C++ 的世界既严谨又充满乐趣！