[C]值传递、指针传递、引用传递

最新推荐文章于 2025-06-23 13:48:00 发布
原创 最新推荐文章于 2025-06-23 13:48:00 发布 · 697 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c语言 #内存 #指针

本文详细解析了C语言中值传递、地址传递及引用传递的概念与应用，通过代码实例展示了不同传递方式对内存的影响，帮助读者理解参数传递机制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

C语言值传递怎么用，引用传递怎么用？

以表格来简要说明并区分这几种传递到底在做什么：

类型传递对象传递行为内存关系适用情况区别与联系举例
值传递数值将实参的数值拷贝到另一块独立的内存上，在新的内存上操作形参和实参占用不同的内存函数内部需要修改参数，并且希望此改变的作用域不涉及调用者传递是单向的，实参->形参函数调用时，参数为数值
地值传递地址直接在实参所在的内存上操作形参指向的和实参所在的是一块内存内部对变量进行操作，并且希望此操作的作用域包括调用者；返回值传递传递是双向的，实参<->实参函数调用时，参数为地址
引用传递别名同上形参和实参是同一个变量的不同名字，拥有相同的内存同上同上实参代替了形参

具体说来，引用/地址传递在返回值传递上的应用是指：
假设函数需要有多个返回值，而显式上不能有返回值或者只能有一个返回值，则此时可利用指针/引用传递，对其他需要返回的变量进行修改，并将修改返回给调用者，完成隐式的返回值传递。
下面我们用代码来直接证明这三种传递在做什么：

#include<iostream>
#include<stdlib.h>
using namespace std;

void swap_value(int a, int b){
    cout << "swap 前，形参的数值和地址：" << endl;
    cout << "value（a） = " << a << "," << "变量a的地址:" << &a << endl;
    cout << "value（b） = " << b << "," << "变量b的地址:" << &b << endl;
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
    cout << "swap 后，形参的数值和地址：" << endl;
    cout << "value（a） = " << a << "," << "变量a的地址:" << &a << endl;
    cout << "value（b） = " << b << "," << "变量b的地址:" << &b << endl;

}

void swap_adress_value(int *a, int *b){
    cout << "swap 前，形参的地址和指向的数值：" << endl;
    cout << "value（a） = " << a << "," << "*a:" << *a << endl;
    cout << "value（b） = " << b << "," << "*b:" << *b << endl;
    int *tmp;
    tmp = a;
    a = b;
    b = tmp;
    cout << "swap 后，形参的地址和指向的数值：" << endl;
    cout << "value（a） = " << a << "," << "*a:" << *a << endl;
    cout << "value（b） = " << b << "," << "*b:" << *b << endl;

}

void swap_pointer(int *a, int *b){
    cout << "swap 前，形参的地址和指向的数值：" << endl;
    cout << "value（a） = " << a << "," << "*a:" << *a << endl;
    cout << "value（b） = " << b << "," << "*b:" << *b << endl;
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
    cout << "swap 后，形参的地址和指向的数值：" << endl;
    cout << "value（a） = " << a << "," << "*a:" << *a << endl;
    cout << "value（b） = " << b << "," << "*b:" << *b << endl;

}

void swap_reference(int &a, int &b){
    cout << "swap 前，形参的地址和指向的数值：" << endl;
    cout << "value（a） = " << a << "," << "a存储地址:" << &a << endl;
    cout << "value（b） = " << b << "," << "b存储地址:" << &b << endl;
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
    cout << "swap 后，形参的地址和指向的数值：" << endl;
    cout << "value（a） = " << a << "," << "a存储地址:" << &a << endl;
    cout << "value（b） = " << b << "," << "b存储地址:" << &b << endl;

}

int main(){
    cout << "值传递：" << endl;
    int x = 10;
    int y = -1;
    cout << "swap 前，实参的数值和地址：" << endl;
    cout << "value（x） = " << x << "," << "变量x的地址:" << &x << endl;
    cout << "value（y） = " << y << "," << "变量y的地址:" << &y << endl;
    swap_value(x, y);

    cout << "swap 后，实参的数值和地址：" << endl;
    cout << "value（x） = " << x << "," << "变量x的地址:" << &x << endl;
    cout << "value（y） = " << y << "," << "变量y的地址:" << &y << endl;


    system("pause");
    cout << endl;
    cout << endl;
    cout << endl;

    cout << "传递地址且对地址进行修改：" << endl;
    x = 10;
    y = -1;
    cout << "swap 前，实参的数值和地址：" << endl;
    cout << "value（x） = " << x << "," << "变量x的地址:" << &x << endl;
    cout << "value（y） = " << y << "," << "变量y的地址:" << &y << endl;
    swap_adress_value(&x, &y);

    cout << "swap 后，实参的数值和地址：" << endl;
    cout << "value（x） = " << x << "," << "变量x的地址:" << &x << endl;
    cout << "value（y） = " << y << "," << "变量y的地址:" << &y << endl;

    system("pause");
    cout << endl;
    cout << endl;
    cout << endl;

    cout << "指针传递：" << endl;
    x = 10;
    y = -1;
    cout << "swap 前，实参的数值和地址：" << endl;
    cout << "value（x） = " << x << "," << "变量x的地址:" << &x << endl;
    cout << "value（y） = " << y << "," << "变量y的地址:" << &y << endl;
    swap_pointer(&x, &y);

    cout << "swap 后，实参的数值和地址：" << endl;
    cout << "value（x） = " << x << "," << "变量x的地址:" << &x << endl;
    cout << "value（y） = " << y << "," << "变量y的地址:" << &y << endl;

    system("pause");
    cout << endl;
    cout << endl;
    cout << endl;

    cout << "引用传递：" << endl;
    x = 10;
    y = -1;
    cout << "swap 前，实参的数值和地址：" << endl;
    cout << "value（x） = " << x << "," << "变量x的地址:" << &x << endl;
    cout << "value（y） = " << y << "," << "变量y的地址:" << &y << endl;
    swap_reference(x, y);

    cout << "swap 后，实参的数值和地址：" << endl;
    cout << "value（x） = " << x << "," << "变量x的地址:" << &x << endl;
    cout << "value（y） = " << y << "," << "变量y的地址:" << &y << endl;

    system("pause");
    cout << endl;
    cout << endl;
    cout << endl;

}

再来看执行结果：

值传递：
swap 前，实参的数值和地址：
value（x） = 10,变量x的地址:0046FD4C
value（y） = -1,变量y的地址:0046FD40
swap 前，形参的数值和地址：
value（a） = 10,变量a的地址:0046FC68
value（b） = -1,变量b的地址:0046FC6C
swap 后，形参的数值和地址：
value（a） = -1,变量a的地址:0046FC68
value（b） = 10,变量b的地址:0046FC6C
swap 后，实参的数值和地址：
value（x） = 10,变量x的地址:0046FD4C
value（y） = -1,变量y的地址:0046FD40
请按任意键继续. . . 



传递地址且对地址进行修改：
swap 前，实参的数值和地址：
value（x） = 10,变量x的地址:0046FD4C
value（y） = -1,变量y的地址:0046FD40
swap 前，形参的地址和指向的数值：
value（a） = 0046FD4C,*a:10
value（b） = 0046FD40,*b:-1
swap 后，形参的地址和指向的数值：
value（a） = 0046FD40,*a:-1
value（b） = 0046FD4C,*b:10
swap 后，实参的数值和地址：
value（x） = 10,变量x的地址:0046FD4C
value（y） = -1,变量y的地址:0046FD40
请按任意键继续. . . 



指针传递：
swap 前，实参的数值和地址：
value（x） = 10,变量x的地址:0046FD4C
value（y） = -1,变量y的地址:0046FD40
swap 前，形参的地址和指向的数值：
value（a） = 0046FD4C,*a:10
value（b） = 0046FD40,*b:-1
swap 后，形参的地址和指向的数值：
value（a） = 0046FD4C,*a:-1
value（b） = 0046FD40,*b:10
swap 后，实参的数值和地址：
value（x） = -1,变量x的地址:0046FD4C
value（y） = 10,变量y的地址:0046FD40
请按任意键继续. . . 



引用传递：
swap 前，实参的数值和地址：
value（x） = 10,变量x的地址:0046FD4C
value（y） = -1,变量y的地址:0046FD40
swap 前，形参的地址和指向的数值：
value（a） = 10,a存储地址:0046FD4C
value（b） = -1,b存储地址:0046FD40
swap 后，形参的地址和指向的数值：
value（a） = -1,a存储地址:0046FD4C
value（b） = 10,b存储地址:0046FD40
swap 后，实参的数值和地址：
value（x） = -1,变量x的地址:0046FD4C
value（y） = 10,变量y的地址:0046FD40
请按任意键继续. . .

      我们结合运行结果来分析一下：
      调用swap_xxx函数之前，变量x，y分别有自己的地址和数值。
      调用函数swap_value时，相当于做了以下2个赋值操作：

a = x；b = y;

     这只是说把x、y的value分别赋给a、b。
     可以通过结果看出，a、b有自己的内存，内存地址与x、y不同。且调出swap_value之后，发生数值交换的仅是内部变量而已，外部变量x、y的地址和数值并没受到影响。
     调用swap_adress_value/swap_pointer时，相当于做了以下2个赋值操作：

*a = &x；*b = &y；

     这里&是取地址的意思，是把x、y的地址分别赋给指针变量a、b，也就是说a有自己的内存地址，这块内存存储的就是x的地址，也即a指向了x。
     只不过，在函数swap_adress_value内部，只是将指针变量a和b的value做了交换。所以外部变量x、y不受任何影响，而内部变量a、b有自己的内存地址，a和b的地址未发生改变，但是a和b的value改变了，a和b指向的变量改变了。
     而在swap_pointer里面，则是将a和b指向的内容作了交换，a和b的value未发生改变，依然指向之前的内存，但是它们指向的内存里面所存储的内容作了交换。同时在外部，x和y依然对应着原来的内存，所以x和y的地址都没有改变，但是里面写入的值却发生了改变。也就是说内部变量交换的时候，是在外部变量所对应的同一块内存空间上进行的。
     调用swap_reference时，相当于做了以下2个赋值操作：

&a = x；&b = y；

     这里&是引用的意思，是说a和x对应着同一块内存，对其中任何一个的修改，另一个都会受到影响，a和x相当于同一个变量的两个名字。所以内部变量a和x的地址一样，数值一样。交换之后，a和x的数值、地址依然一样。

#define
#ifdef的用途
#include的作用

#include是文件包含指令，在程序编译时，把#include后面指定文件的内容包含进当前的文件中。主要有2种形式：
1、#include<file.h>
从标准库中寻找file.h文件，是系统库头文件，根据一定的规则查找filh.h。
2、#include”file.h”
从工程目录下开始寻找file.h文件，是自定义的头文件，在源文件所在位置查找filh.h。

typedef
C语言工程的编译过程

如下图所示：
这里写图片描述

C程序的内存分布
数组的初始化
数组和指针的联系与区别
为什么数组不能更改指向地址？这样设计的动机是什么？
void指针是什么？
函数指针怎么定义？
函数指针的用途是什么？
malloc和free，什么时候需要用它们？
【C语言】值传递和指针传递
数字人生
10-10 667
值传递：函数接收的是实参的副本，对形参的修改不会影响实参。指针传递：函数接收的是指向实参的指针，可以通过指针直接修改实参的值。选择哪种传递方式取决于具体的需求和场景。对于简单数据类型，值传递通常已经足够；而对于复杂的数据结构或需要修改实参的场景，指针传递是更好的选择。在C语言中，函数参数的传递方式主要有两种：值传递（Pass by Value）和指针传递（Pass by Pointer）。这两种方式在函数调用时对参数的处理方式不同，因此对函数内部和外部的变量影响也不同。值传递。
C语言入门系列：从内存原理看函数的值传递和引用传递
epitomizelu的专栏
06-23 1104
函数参数用于向函数传递数据，C语言支持两种传递方式：值传递和引用传递。
C++的引用传递
2301_80872441的博客
05-24 3642
数据类型 &别名＝原名int main()int a = 20;int& b = a;
C/C++语言中值传递、指针传递和引用传递
彼此当年少，莫负好时光
01-06 1万+
在C语言中值传递、指针传递和引用传递这三种函数参数传递方式是比较基本的知识，用的比较普遍，但不仔细分析其实质的话，时间长容易记混了。网上的资料也较多但多数都不系统，本文力求用最白话的表达和简单的示例把这三种方式描述清楚。没时间看分析的直接看简述就可以了。 简述 值传递就是最普通的传递方式，比如函数定义为fun(int a)，在调用的地方有int x=6， 使用fun(x)就可以了。这种方式在
C语言函数传参的三大误区：值传递、指针传递与引用传递深度对比
最新发布
星辰夜语的博客
06-23 1074
在C语言编程中，函数传参是一个基础且关键的概念。正确理解和运用函数传参的方式，对于编写高效、稳定的代码至关重要。然而，很多开发者在函数传参方面存在一些误区，尤其是对于值传递、指针传递和容易与指针传递混淆的引用传递（C语言本身没有严格意义上的引用传递，但在概念上常与指针传递对比）。本文将深入剖析这三种传参方式，揭示常见误区，并通过详细的代码示例进行对比，帮助技术人员准确掌握它们的区别和应用场景。
c语言值传递，地址传递，引用传递（引用传递只适用于c++）
Wendell的计算机之旅
06-04 1万+
一． 三道考题开讲之前，我先请你做三道题目1. 考题一：程序代码如下：void Exchg1(int x, int y)  {  int tmp;  tmp=x;  x=y;  y=tmp;  printf(“x=%d,y=%d/n”,x,y)}void main(){  int
C--值传递、指针传递和引用传递（C++）
天道酬勤
06-05 626
一、基本介绍 1、值传递：形参是实参的副本（复制、拷贝），形参值的改变不会影响实参的值，这种方式用的最多。 2、指针传递：形参是指针类型，形参作指针运算后指向的就是实参，所以会影响实参的值，这种方式用的也很多。 3、引用传递（C++）：在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际 参数。这种方式用的也蛮多的。（引用只是一个别名）   二、代码示...
C值传递和引用传递
丹铅甲乙的博客
05-14 499
值传递和引用传递最熟悉的例子应该是两个参数的交换了，我们知道值传递中对形参的修改不会影响实参，引用传递中对形参的修改会作用于实参。那么为什么会这样呢？ 值传递的例子#include <stdio.h> #include <stdlib.h>void change(int value) { value = 10; }int main() { int a = 5; change(a
值传递，指针传递，引用传递的区别，内含可运行代码和详细解释
10-08
总结：在实际使用中，值传递一方面会占用内存空间，内置类型还好（int等），如果是类（class）类型,赋值可能会是很大一笔...而对于指针传递，则在涉及数组的情况下使用较多，因为指针本身会给代码增加复杂性，难维护性
C语言中 值传递和指针传递实例详解
08-30
在C语言中，函数参数的传递主要有两种方式：值传递（Value Passing）和指针传递（Pointer Passing）。这两种方式有着显著的区别，理解它们的工作原理对于编写高效、灵活的代码至关重要。 1. 值传递（Value Passing...
漫谈：C语言 值传递 函数参数 指针
编程之道在明明德在亲民在止于至善
04-11 1048
漫谈：C语言 值传递 函数参数 指针
c语言函数引用传递和指针传递参数,c语言函数到底是值传递还是引用传递？
weixin_32667011的博客
05-21 222
之前一直以为C语言中的函数是值传递，但是今天看到一本书上的一个例子代码，如下：#include #define MAXLINE 1000 /* maximum input line length */int getline(char line[], int maxline);void copy(char to[], char from[]);/* print the longest inpu...
C/C++中函数参数传递的三种方式:值传递，指针传递，引用传递
leesan0802的专栏
04-07 8641
对C/C++中函数传参的方式进行了介绍和说明
c语言中变量的引用传递和指针
千淘万漉
08-02 2万+
掌握了引用型变量和指针，才能深入掌握面向过程的函数调用机制。 引用型变量存储的是变量的地址，指针存储的也是变量的地址，所以本质上来说二者是一样的。 使用引用型变量，子函数中所有的操作会直接修改主函数中的实参，鼓励使用引用型变量。 编程的本质不就是改变量么？通过引用型变量和指针型变量可以让子函数直接改主函数中的变量，而不再需要为形参开辟内存。 //如果子函数在主函数下面，一定要先声明
C语言的指针传递和C++的引用传递
weixin_40908748的博客
06-21 1940
首先，C语言没有引用传递。 C++中使用引用传递的方式是在函数的参数前加&号，如： void Delete_X(LinkList &L, ElemType x) // 声明 Delete_X(L, 45); // 使用 C：指针作为参数传入函数中时，是值传递 示例代码： #include <stdio.h> void fun(i...
c语言中变量的引用传递和指针,c语言的值传递、指针传递、引用传递的区别
weixin_39626745的博客
05-18 378
1. 值传递：形参是实参的拷贝，改变形参的值并不会影响外部实参的值。从被调用函数的角度来说，值传递是单向的(实参->形参)，参数的值只能传入，不能传出。当只希望是函数内部修改参数，并且不希望改变被调用者时，采用值传递。void swap(int a,int b) { int temp; temp=a; a=b; b=temp; cout&lt...
c语言 指针和引用传递参数,漫谈C指针：参数的引用传递
weixin_28931507的博客
05-18 377
看题三的代码：#include "stdio.h"void Exchg3(int &x, int &y) /* 注意定义处的形式参数的格式与值传递不同 */{int tmp = x;x = y;y = tmp;printf("x = %d, y = %d.\n", x, y);}main(){int a = 4;int b = 6;Exchg3(a, b); /*注意：这里调用方式...
C#值传递、引用传递、输出传递详解
这个人好有趣....hh
02-23 4697
1、值传递 2、引用传递， 3、输出传递 4、ref 和 out 我们先来介绍一下形式参数（形参）和实际参数（实参）这两个概念： ，使用 return 语句可以从函数中返回一个值，但是使用输出传递则可以从函数中一次性返回多个值。
C/C++的指针传递和引用传递
热门推荐
Serven的博客
04-12 2万+
C/C++指针传递和引用传递傻傻分不清楚
指针传递 值传递 引用传递
04-02
<think>好的，我现在需要回答用户关于C++中指针传递、值传递和引用传递的区别及应用场景的问题。首先，我需要回顾一下已有的参考资料，确保准确理解每个传递方式的特点。 首先，根据引用[1]、[2]、[4]，值传递是将实参的副本传递给函数，函数内部修改的是副本，不影响原始值。这点在示例代码中也很清楚，比如modifyValue函数里的x被修改为100，但main函数中的a仍然保持原值。这说明值传递适用于不需要修改原始数据的场景，或者处理小型数据时效率较高的情况。 接下来是引用传递，引用[3]和[4]提到，引用传递是传递变量的别名，函数内对引用的操作直接影响原始变量。引用必须初始化且不能为空，这使得它在需要直接修改原变量或者传递大型数据结构时更高效，避免了拷贝开销。例如，swap函数使用引用参数可以直接交换两个变量的值，而不需要指针的语法。 然后是指针传递。根据引用[3]、[5]，指针传递实际上是传递指针的副本，这个副本指向原变量的地址。因此，通过指针可以修改原变量的值，但无法改变原指针的指向。指针允许传递空值，这在需要可选参数或动态内存管理时非常有用。例如，当函数需要处理可能为null的情况，或者需要重新分配内存时，指针更合适。 现在需要比较三者的区别。值传递和引用/指针传递的主要区别在于是否复制数据以及能否修改原数据。引用和指针都能修改原数据，但引用更安全，因为不能为空，语法也更简洁。而指针则更灵活，允许空值和地址操作。 应用场景方面，值传递适合小型数据或不需修改的场景；引用传递适合需要修改原数据或大型数据；指针适合可选参数、动态内存或需要改变指向的情况。例如，动态数组处理可能用指针，而交换变量值用引用更直观。 需要注意，其他语言如Java的参数传递机制不同，可能只有值传递，但对象类型传递的是引用的副本。这部分可能需要简要提及，但用户主要关注C++，所以重点在C++的区别。 最后，需要检查是否有遗漏或错误。比如，确认引用不能为空是否正确，以及指针传递中能否改变原指针的指向。根据引用[3]，指针传递时形参是实参的拷贝，因此修改形参的指向不会影响实参指针，但可以通过解引用修改指向的数据。 总结：结构上先分别介绍三种传递方式，再对比区别，最后说明应用场景，并附上示例代码。确保回答清晰，引用正确，符合用户要求的中文和格式要求。</think>### 指针传递 vs 值传递 vs 引用传递的区别与使用场景 在 C++ 中，函数参数传递方式主要分为**值传递**、**指针传递**和**引用传递**。它们的行为差异主要体现在内存操作、性能开销和应用场景上。 --- ### 一、核心区别 #### 1. **值传递** - **定义**：将实参的**副本**传递给函数，函数内操作的是副本，不影响原始数据。 - **特点**： - 适用于小型数据（如基本类型）。 - 无法通过形参修改实参的值。 - 默认的传递方式（无需特殊语法）。 - **示例**： ```cpp void modifyValue(int x) { x = 100; // 修改副本，不影响实参 } int main() { int a = 10; modifyValue(a); std::cout << a; // 输出 10 } ``` #### 2. **指针传递** - **定义**：传递变量的**内存地址**，函数通过指针间接操作原始数据。 - **特点**： - 允许修改实参的值（通过解引用）。 - 指针本身是值传递（传递的是地址的副本），因此无法通过形参指针修改实参指针的指向[^3]。 - 支持空值（`nullptr`），适合可选参数或动态内存管理[^5]。 - **示例**： ```cpp void modifyByPointer(int* ptr) { *ptr = 100; // 通过指针修改实参的值 } int main() { int a = 10; modifyByPointer(&a); std::cout << a; // 输出 100 } ``` #### 3. **引用传递** - **定义**：传递变量的**别名**，函数内操作直接影响原始数据。 - **特点**： - 语法简洁（无需解引用）。 - 引用必须初始化且不能为空。 - 无法通过形参引用修改实参引用的绑定关系。 - 性能高效（避免大型对象的拷贝开销）[^4]。 - **示例**： ```cpp void modifyByReference(int& ref) { ref = 100; // 直接修改实参的值 } int main() { int a = 10; modifyByReference(a); std::cout << a; // 输出 100 } ``` --- ### 二、对比总结 | 特性 | 值传递 | 指针传递 | 引用传递 | |---------------------|---------------------|-----------------------|-----------------------| | **内存操作** | 操作副本 | 通过地址操作原始数据 | 直接操作原始数据 | | **空值支持** | 不适用 | 支持（`nullptr`） | 不支持 | | **语法复杂度** | 简单 | 需解引用（`*`） | 简洁（无特殊符号） | | **适用场景** | 小型数据、只读操作 | 动态内存、可选参数 | 大型对象、需修改实参 | --- ### 三、使用场景 1. **值传递**： - 函数无需修改原始数据（如数学计算）。 - 处理小型数据（如`int`, `char`）时性能更优[^2]。 2. **指针传递**： - 需要传递空值或可选参数（如链表节点）。 - 动态内存管理（如`new`/`delete`操作）[^5]。 - 需在函数内改变指针指向（需使用指针的指针）。 3. **引用传递**： - 需要直接修改原始数据（如交换函数`swap`）。 - 传递大型对象（如类实例、容器）避免拷贝。 - 实现运算符重载（如`operator<<`）。 --- ### 四、其他语言中的差异 - **Java/Python**：仅支持值传递，但对象类型传递的是引用的副本（形似引用传递，实为值传递）。 - **Rust**：通过所有权机制限制引用和指针的使用，避免内存安全问题。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值