异常教程

C++ 传递指针给函数（长文讲解）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

前言：为什么需要传递指针给函数？

在 C++ 程序设计中，函数是组织代码的核心单元。当我们希望函数能够修改调用者的数据，或希望函数返回多个结果时，传递指针给函数便成为了一种强大且灵活的解决方案。通过传递指针，函数可以间接操作变量的存储地址，实现数据的高效共享与修改。

这一机制类似于现实中的快递服务：快递员（指针）携带包裹（数据）在不同地址（内存空间）之间传递。与直接传递数据（如包裹的复印件）不同，指针传递的是“地址信息”，从而避免了数据的重复拷贝，同时也允许函数对原始数据进行直接操作。

本文将从基础概念出发，结合代码示例和实际案例，逐步解析如何正确、安全地传递指针给函数，并探讨其在编程实践中的应用场景与注意事项。

一、指针基础：理解内存地址与间接访问

1.1 什么是内存地址？

每个变量在内存中都有一个唯一的地址（即内存单元编号）。例如，整型变量 int a = 10; 的值存储在内存地址 0x7ffee3456780 处（假设地址值）。通过指针，我们可以直接操作这些地址，而不仅仅是变量的值。

1.2 指针的声明与使用

指针变量用于存储其他变量的地址。其语法形式为：

数据类型 *指针变量名;

示例：

int num = 20;
int *ptr = # // ptr 存储 num 的地址

1.3 通过指针间接访问数据

使用 * 运算符（解引用运算符）可以获取指针指向的值：

std::cout << *ptr; // 输出 20，即 num 的值

二、传递指针给函数的核心原理

2.1 函数参数传递的两种方式

在 C++ 中，函数参数传递主要有两种形式：

  1. 值传递：将变量的值复制一份传入函数，函数无法修改原始数据。
  2. 地址传递（指针传递）：将变量的地址传递给函数，函数可以通过该地址直接修改原始数据。

2.2 指针传递的优势

  • 高效性：避免大对象的拷贝，节省内存和时间。
  • 修改能力：允许函数修改调用者的数据。
  • 多返回值：通过指针或引用返回多个结果。

2.3 指针传递的语法

函数参数声明为指针类型：

void modifyValue(int *ptr) {
    *ptr = 50; // 修改原始变量的值
}

调用时传递变量的地址：

int main() {
    int x = 10;
    modifyValue(&x); // 输出结果将变为 50
    return 0;
}

三、传递指针的常见场景与案例

3.1 场景一：修改调用者的数据

案例：交换两个整数的值

#include <iostream>
using namespace std;

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 3, y = 7;
    cout << "Before swap: x = " << x << ", y = " << y << endl;
    swap(&x, &y);
    cout << "After swap: x = " << x << ", y = " << y << endl;
    return 0;
}

输出：

Before swap: x = 3, y = 7
After swap: x = 7, y = 3

3.2 场景二：动态内存管理

当函数需要返回动态分配的内存时，可以通过指针传递实现：

#include <cstdlib>

void allocateMemory(int **ptr, int size) {
    *ptr = (int *)malloc(size * sizeof(int));
}

int main() {
    int *arr = nullptr;
    allocateMemory(&arr, 5);
    // 使用 arr 进行操作后，需调用 free 释放内存
    free(arr);
    return 0;
}

3.3 场景三：函数间数据共享

指针传递允许函数间共享复杂数据结构（如数组、结构体）：

struct Person {
    char name[50];
    int age;
};

void updateAge(Person *person, int newAge) {
    person->age = newAge; // 使用箭头运算符访问结构体成员
}

int main() {
    Person john = {"John Doe", 25};
    updateAge(&john, 30);
    cout << "John's new age: " << john.age << endl;
    return 0;
}

四、指针传递与引用传递的对比

特性指针传递引用传递
语法需要显式传递地址（& 运算符）自动绑定变量，无需 &
可变性可以修改指针本身指向的地址引用一旦初始化不可更改
默认值允许 nullptr不允许未初始化的引用
灵活性可处理动态内存和复杂操作语法简洁，适合简单场景

示例对比：

// 指针版本
void modify(int *p) { *p = 100; }

// 引用版本
void modify(int &r) { r = 100; }

int main() {
    int x = 0;
    modify(&x); // 指针调用
    modify(x);  // 引用调用（自动传递地址）
    return 0;
}

五、注意事项与常见错误

5.1 空指针（Null Pointer）的陷阱

未初始化的指针可能指向随机地址，导致程序崩溃。务必在使用前初始化指针：

int *ptr; // 错误：未初始化
*ptr = 10; // 未定义行为

int *safe_ptr = nullptr; // 正确：显式置空
if (safe_ptr != nullptr) {
    *safe_ptr = 10; // 需确保指针有效
}

5.2 指针与数组的交互

传递数组时，函数参数可以声明为指针或数组：

void processArray(int arr[], int size); // 等价于 void processArray(int *arr, int size);

但需注意数组名在函数参数中会退化为指针，因此无法获取原始数组长度。建议显式传递数组大小。

5.3 内存泄漏与悬垂指针

动态分配的内存必须显式释放，否则会导致内存泄漏：

void createObject(int **ptr) {
    *ptr = new int(42); // 动态分配
}

int main() {
    int *obj = nullptr;
    createObject(&obj);
    delete obj; // 必须释放内存
    return 0;
}

六、高级技巧与优化

6.1 通过指针返回多个值

函数可通过指针参数返回多个结果：

void getMinMax(const int arr[], int size, int *min, int *max) {
    *min = *max = arr[0];
    for (int i = 1; i < size; ++i) {
        if (arr[i] < *min) *min = arr[i];
        if (arr[i] > *max) *max = arr[i];
    }
}

int main() {
    int nums[] = {5, 3, 9, 1, 7};
    int minVal, maxVal;
    getMinMax(nums, 5, &minVal, &maxVal);
    cout << "Min: " << minVal << ", Max: " << maxVal << endl;
    return 0;
}

6.2 指针与函数指针的结合

通过函数指针实现动态行为选择：

typedef void (*Operation)(int *);

void increment(int *num) { *num += 1; }
void decrement(int *num) { *num -= 1; }

void applyOperation(int *num, Operation op) {
    op(num);
}

int main() {
    int x = 5;
    applyOperation(&x, increment); // x 变为 6
    applyOperation(&x, decrement); // x 变为 5
    return 0;
}

结论：掌握指针传递的关键

通过本文的学习，我们明确了以下核心要点：

  1. 指针传递允许函数直接操作原始数据，这是实现高效、灵活代码的重要手段。
  2. 合理选择指针或引用，根据场景需求权衡语法简洁性与功能扩展性。
  3. 时刻注意内存安全，避免空指针、悬垂指针和内存泄漏。

建议读者通过以下步骤实践：

  1. 从简单的交换变量案例开始，逐步尝试动态内存管理、结构体操作等复杂场景。
  2. 使用调试工具（如 GDB）观察指针变化，加深对内存操作的理解。
  3. 参考标准库源码（如 std::sort 的比较函数），学习指针传递的工业级应用。

掌握指针传递，将为 C++ 程序设计打开更广阔的可能性，帮助开发者构建高效、可维护的复杂系统。

最新发布

查看更多文章