1. 从一个经典翻车现场说起
刚入行那会儿，我写过一个看起来人畜无害的函数，大概长这样：
void swap(int a, int b) { int tmp = a; a = b; b = tmp; }调用方老老实实传了两个变量进去，结果打印出来一看，两个值纹丝不动。当时我盯着屏幕怀疑人生，后来才反应过来——这是传值，函数里操作的只是实参的一份拷贝，改拷贝跟改原件是两码事。
这个坑几乎每个C/C++学习者都会踩一次。而它背后牵扯出的，正是函数参数传递这个看似基础、实则贯穿整个编程生涯的核心话题：传值、传指针、传引用。这三个词你可能听过无数遍，但真正能把它们讲清楚、用对地方、避开所有暗坑的人，其实没那么多。
这篇内容就是围绕这个主题展开的。我会把三种传递方式的底层机制、内存模型、适用场景、性能差异、常见误区和排查技巧全部拆开揉碎讲一遍。不管你是刚学C语言被指针绕晕的新手，还是写了几年C++但对引用和指针的取舍仍然模糊的老手，都能从中找到能直接抄作业的结论。特别强调一点：C语言本身不支持传引用，这是标题里就点明的关键前提，后面我会专门用一节讲清楚为什么，以及C程序员该怎么绕过这个限制。
2. 三种传递方式的本质区别
2.1 先搞清楚一个前提：形参和实参是两套东西
在展开之前，必须先把两个概念钉死，否则后面全是糊涂账。
实参是调用函数时真正传进去的那个东西，形参是函数定义里用来接收的那个变量。它们住在不同的内存区域，生命周期也完全不同。理解参数传递，本质上就是理解"实参的值/地址/别名，是怎么一步步映射到形参上的"。
打个生活化的比方：实参是你家保险柜里的原件，形参是函数这个"办事窗口"拿到的东西。传值相当于窗口复印了一份你的文件，传指针相当于窗口拿到了你保险柜的地址，传引用相当于窗口直接给你的保险柜挂了个别名，动别名就是动原件。
2.2 传值：拷贝一份，互不干扰
传值是C和C++默认的传递方式。调用时，实参的值被复制一份，赋给形参。函数内部无论怎么折腾形参，都不会影响外面的实参。
void modify(int x) { x = 100; // 只改了拷贝 } int main() { int n = 5; modify(n); printf("%d\n", n); // 输出 5，不是 100 }内存上发生了什么？调用modify(n)时，系统在函数栈帧里给形参x分配了一块新空间，把n的值5拷进去。之后x和n就是两个独立的变量，地址不同，改谁都不影响谁。
传值的优点是安全、简单、无副作用，函数不会意外改到调用方的数据。缺点是有拷贝开销。对于int、char这种小类型，拷贝成本可以忽略；但如果传的是一个几百字节的结构体，每次调用都要完整复制一遍，性能就成问题了。
2.3 传指针：把地址递进去，间接操作原件
传指针的本质仍然是传值——只不过传的这个"值"是一个地址。形参是一个指针变量，它保存了实参的地址，于是函数可以通过这个地址去访问、修改真正的数据。
void modify(int *p) { *p = 100; // 通过地址改到了原件 } int main() { int n = 5; modify(&n); printf("%d\n", n); // 输出 100 }这里的关键在于：形参p本身也是被拷贝的，但拷贝的是地址。地址指向的还是同一个n，所以*p = 100改的是原件。
传指针解决了传值"改不到外面"的问题，同时避免了传大对象的拷贝开销——因为传的只是一个地址（通常4或8字节）。但它引入了新的风险：空指针、野指针、指针越界。函数内部如果不检查p是否为NULL就直接解引用，程序当场崩溃。
2.4 传引用：C++的语法糖，本质还是地址
C++引入了引用，写法上更清爽：
void modify(int &r) { r = 100; // 直接改，不用解引用 } int main() { int n = 5; modify(n); printf("%d\n", n); // 输出 100 }引用看起来像是"直接传了变量本身"，但底层实现几乎和指针一模一样——编译器通常也是通过地址来实现引用的。区别在于语法层面：引用必须在定义时绑定到一个对象，之后不能重新绑定，也不能为空。这就省掉了指针那一堆*和&的符号噪音，同时天然规避了空指针问题。
2.5 一张表看清三者差异
| 维度 | 传值 | 传指针 | 传引用（C++） |
|---|---|---|---|
| 传递内容 | 值的拷贝 | 地址的拷贝 | 对象的别名 |
| 能否修改实参 | 不能 | 能 | 能 |
| 是否产生拷贝 | 是（整个对象） | 是（仅地址） | 否（语义上） |
| 能否为空 | 不适用 | 能（NULL） | 不能 |
| 能否重新绑定 | 不适用 | 能 | 不能 |
| 语法复杂度 | 低 | 中（需解引用） | 低 |
| C语言支持 | 支持 | 支持 | 不支持 |
这张表建议直接存下来，面试和实际选型时都能用。
3. 为什么C语言不支持传引用
3.1 引用是C++的语言特性，不是C的
很多人第一次听到"C语言不支持传引用"会愣一下，因为平时写C++写顺手了，以为引用是通用概念。实际上，引用（reference）是C++在C的基础上新增的语言级特性，C标准里根本没有这个东西。
C语言的设计哲学是"贴近硬件、机制简单、不隐藏开销"。引用这种"看起来像变量、实际是别名"的东西，在C的设计者看来属于语法糖，会增加语言复杂度，所以没有纳入。C里想达到类似效果，只能显式用指针。
3.2 C程序员的替代方案
在C里，所有"传引用"想做的事，都能用指针完成，只是写法上多几个符号：
// C++ 传引用写法 void addOne(int &r) { r += 1; } // C 的等价写法 void addOne(int *p) { (*p) += 1; }调用时C++写addOne(n)，C写addOne(&n)。功能完全一致，只是C需要调用方显式取地址、函数内显式解引用。这种"显式"恰恰是C的风格——让你清楚知道自己在操作地址。
3.3 一个容易混淆的点：C里的"引用"这个词
有时候你会看到C代码里说"引用某个变量"，那只是日常用语，指"使用"或"指向"，跟C++的引用类型完全是两码事。看到"C语言传引用"这种说法，基本可以判定是表述不严谨，正确说法应该是"通过指针间接传递"。
注意：如果你在C项目里看到有人声称用了"引用传递"，先确认他是不是其实在用C++编译器编译
.c文件，或者用了某些扩展。标准C里没有引用。
4. 传指针的深水区：二级指针与数组退化
4.1 想改指针本身，得传指针的指针
传指针能改指针指向的内容，但如果函数想修改指针本身（比如让它指向新分配的内存），就得传二级指针：
void alloc(int **pp) { *pp = (int *)malloc(sizeof(int)); **pp = 42; } int main() { int *p = NULL; alloc(&p); // 传指针的地址 printf("%d\n", *p); // 输出 42 free(p); }为什么？因为形参pp是p的地址的拷贝，通过*pp才能改到p本身。这是新手最容易卡住的地方，记住一句话：想改什么，就传什么的地址。想改int，传int*；想改int*，传int**。
4.2 数组作为参数会"退化"成指针
void func(int arr[10]) { printf("%zu\n", sizeof(arr)); // 输出指针大小，不是40 }数组作为函数参数时，会退化为指向首元素的指针，长度信息丢失。所以int arr[10]和int *arr在形参位置上完全等价。这就是为什么传数组通常要额外传一个长度参数：
void func(int *arr, size_t len) { /* ... */ }实操心得：永远不要依赖
sizeof(arr)/sizeof(arr[0])在函数内部算数组长度，那个arr已经是指针了，算出来必然是错的。长度老老实实当参数传。
4.3 const指针的三种组合
传指针时经常配合const表达意图，三种写法含义不同：
| 写法 | 含义 | 能否改指向 | 能否改内容 |
|---|---|---|---|
const int *p | 指向常量的指针 | 能 | 不能 |
int * const p | 常量指针 | 不能 | 能 |
const int * const p | 两者都常 | 不能 | 不能 |
函数参数里最常见的是const int *p，表示"我只读你的数据，不改"，既表达了意图，又能接收const和非const实参。
5. 传引用的正确打开方式与陷阱
5.1 什么时候该用引用而不是指针
C++里选引用还是指针，我的一般原则是：
- 参数一定存在、且必须绑定到对象：用引用。比如
void print(const std::string &s)。 - 参数可能为空、或者需要表示"没有"：用指针。比如查找函数返回
nullptr表示没找到。 - 需要重新绑定到不同对象：用指针。
- 大对象只读传递：用
const T&，避免拷贝又不改数据。
5.2 const引用：大对象传参的标配
void process(const std::vector<int> &data) { // 只读，不拷贝，不修改 }如果写成void process(std::vector<int> data)，每次调用都会完整拷贝一个vector，元素多的时候开销巨大。加上const &，既避免了拷贝，又保证了函数不会改数据，还能接收临时对象（右值），是C++里最常用的参数形式之一。
5.3 返回引用：小心悬空引用
引用不仅能当参数，还能当返回值，但这里有个大坑：
int& bad() { int local = 10; return local; // 危险！local在函数返回后销毁 }返回局部变量的引用，函数一结束局部变量就没了，调用方拿到的是悬空引用，用它是未定义行为。返回引用只适用于返回生命周期长于函数的对象，比如类的成员、静态变量、或者传入的参数。
踩过的坑：曾经有个函数返回了容器内部元素的引用，结果容器在别处被清空了，引用还在用，程序随机崩溃，查了两天才定位到。返回引用时，一定要想清楚这个对象的生命周期。
6. 性能与选型：到底该用哪个
6.1 小类型直接传值
int、char、double、指针本身这类小类型，传值最省事，拷贝成本几乎为零，还避免了间接访问。不要为了"显得高级"给int加个const&，反而多一层间接。
6.2 大对象传const引用（C++）或const指针（C）
结构体、类对象、容器这类大对象，传值拷贝代价高，应该传const T&（C++）或const T*（C）。这是性能优化的基本操作。
6.3 需要修改实参时
- C++：优先用引用，语法干净，且不会为空。
- C：只能用指针，记得判空。
6.4 一个简单的决策流程
- 需要修改实参吗？不需要 → 走第2步；需要 → 走第3步。
- 对象大吗？不大 → 传值；大 → 传
const引用/指针。 - C++且参数必不为空 → 传引用；C或参数可能为空 → 传指针。
按这个流程走，基本不会选错。
7. 常见问题与排查技巧实录
7.1 常见问题速查表
| 现象 | 可能原因 | 排查方向 |
|---|---|---|
| 函数内改了参数，外面没变 | 用了传值 | 检查形参是否是指针/引用 |
| 程序崩溃在解引用处 | 空指针或野指针 | 打印指针值，检查是否判空 |
| 数组长度算错 | 数组退化成指针 | 长度单独传参 |
| 返回引用后数据错乱 | 悬空引用 | 检查被引用对象生命周期 |
| 想改指针本身没生效 | 只传了一级指针 | 改用二级指针 |
| 大对象传参卡顿 | 传值导致深拷贝 | 改传const引用/指针 |
7.2 独家避坑技巧
技巧一：形参命名带前缀。我习惯把指针形参命名为p_xxx，引用形参命名为r_xxx，一眼就能看出这个参数是地址还是别名，读代码时少犯错。
技巧二：能加const就加。只读参数一律加const，编译器会帮你挡住误写，还能让调用方放心传const对象。
技巧三：传指针先判空。函数入口处对指针参数做一次if (p == NULL) return;，比崩溃后回头查要省事得多。
技巧四：用引用替代指针时，想清楚"空"的语义。如果业务上确实存在"没有这个参数"的情况，别硬用引用，老老实实用指针加判空。
技巧五：调试时打印地址。遇到参数传递相关的诡异问题，把实参和形参的地址都打印出来对比，是不是同一块内存一目了然，比盯着代码猜快得多。
7.3 一个真实的排查案例
某次一个函数负责往传入的缓冲区写数据，调用方发现缓冲区一直是空的。排查过程：先确认函数被调用了（加日志），再打印形参指针地址和调用方缓冲区地址——发现两者不同。原来函数签名写的是void fill(char *buf)，但调用方传的是char buf[100]，这本身没问题。真正的问题是函数内部写成了buf = new char[100]，把形参指针重新指向了新内存，写进去的数据全在新内存里，跟调用方的缓冲区没关系了。改成往buf指向的内存里写（memcpy(buf, ...)）就对了。
这个案例的教训就是前面说的：形参指针被重新赋值，只影响形参自己，不影响实参。想改指针本身，得传二级指针。
8. 写在最后的一点个人体会
参数传递这块内容，看起来是入门知识，但我见过太多工作三五年的人还在上面栽跟头。核心原因就一个：没有真正建立内存模型。一旦你脑子里能清晰地画出"实参在哪、形参在哪、它们之间是拷贝关系还是指向关系"，所有问题都会变得理所当然。
我个人的习惯是，写任何带参数的函数时，先问自己三个问题：这个参数我要不要改？它会不会为空？它大不大？三个问题答完，用值、用指针还是用引用，答案自然就出来了。至于C和C++的差异，记住一句话就够了——C只有值和指针，引用是C++的专属工具，别在C里找它。
