精华内容
下载资源
问答
  • C/C++语言中值传递、指针传递和引用传递

    万次阅读 多人点赞 2018-01-06 00:09:00
    在C语言中值传递、指针传递和引用传递这三种函数参数传递方式是比较基本的知识,用的比较普遍,但不仔细分析其实质的话,时间长容易记混了。网上的资料也较多但多数都不系统,本文力求用最白话的表达和简单的示例把...

    在C/C++语言中值传递、指针传递和引用传递(C++ only)这三种函数参数传递方式是比较基本的知识,用的比较普遍,但不仔细分析其实质的话,时间长容易记混了。网上的资料也较多但多数都不系统,本文力求用最白话的表达和简单的示例把这三种方式描述清楚。没时间看分析的直接看简述就可以了。

    简述

    值传递就是最普通的传递方式,比如函数定义为fun(int a),在调用的地方有int x=6, 使用fun(x)就可以了。这种方式在fun(int a)函数内部的对a的修改 不能 导致外部x的变化。
    指针传递其实也就是地址传递,函数定义为fun(int *a),形参为指针,这就要求调用的时候传递进去一个参数的地址,例如int x=6; fun(&x)。 这种方式在fun(int a)函数内部的对a的修改 导致外部x的变化。
    引用传递只有C++支持,相比前两种方式用的比较少,但也非常有用。引用传递函数定义为fun(int &a),这里&符号是引用而不是取地址的意思,调用方式和值传递类似,例如int x=6; fun(x)。 但是这种方式在fun(int a)函数内部的对a的修改 导致外部x的变化。

    表格是一种比较直接的表达方式,列个表格可以对这三种方式一目了然,假设调用fun函数之前都有定义int x=6,这三种方式异同如下表所示:

    传递方式函数定义函数调用函数内对a修改的影响
    值传递fun(int a)fun(x)外部x不变
    指针传递fun(int *a)fun(&x)外部x同步更改
    引用传递(C++)fun(int &a)fun(x)外部x同步更改

    分析

    下面三部分代码都尝试在swap函数内对输入参数进行数值交换,通过打印其数值和指针来分析。

    值传递

    函数内部使用这个参数,对这个参数的修改对函数外的原始数据不起作用。

    示例:

    #include <stdio.h>
    
    void swap(int a, int b){
        printf("swap enter\n");
        printf("a = %d, ptr = %p\n", a, &a);
        printf("b = %d, ptr = %p\n", a, &b);
    
        int tmp = b;
        b = a;
        a = tmp;
    
        printf("a = %d, ptr = %p\n", a, &a);
        printf("b = %d, ptr = %p\n", b, &b);
        printf("swap leave\n");
    }
    
    int main() {
        int x = 1;
        int y = 2;
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        swap(x, y);
    
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        return 0;
    }
    

    运行结果:

    x = 1, ptr = 000000000022FE4C
    y = 2, ptr = 000000000022FE48
    swap enter
    a = 1, ptr = 000000000022FE20
    b = 1, ptr = 000000000022FE28
    a = 2, ptr = 000000000022FE20
    b = 1, ptr = 000000000022FE28
    swap leave
    x = 1, ptr = 000000000022FE4C
    y = 2, ptr = 000000000022FE48
    

    结果表明:
    swap函数内部a b的数值进行交换,但是没有影响到x y的值。swap函数形参a b所指向的内存地址和外部x y的地址不一样。
    实质:
    swap为形式参数 a b创建了内存空间,main函数调用swap函数的时候,把x y的值copy给新创建的 a ba bx y分别在不同的内存位置中,因而对这个新创建的 a b 操作不会影响外部的 x y的值。

    带有返回值的函数,比如int fun(){int x=7; return x},外部调用方式为int a=fun();,这时是把x的数值copy了一份给外部a所在的内存空间,并释放了x所在的内存空间(系统自动分配的栈内存),在fun函数调用后即使知道x的内存地址也可能取不到相应的数据。
    返回值为指针的函数,比如char *fun(){...; return str;},函数中待返回的变量必须是使用malloc等函数手动申请空间(堆内存)的数据,且外部使用后要手动释放。因为系统自动申请的栈内存会在函数调用后自动释放。

    指针传递(地址传递)

    形参为指向实参地址的指针,当对形参的指向操作时,就相当于操作实参本身。

    示例:

    #include <stdio.h>
    
    void swap(int *a, int *b){
        printf("swap enter\n");
        printf("a = %d, ptr = %p\n", *a, a);
        printf("b = %d, ptr = %p\n", *a, b);
    
        int tmp = *b;
        *b = *a;
        *a = tmp;
    
        printf("a = %d, ptr = %p\n", *a, a);
        printf("b = %d, ptr = %p\n", *b, b);
        printf("swap leave\n");
    }
    
    int main() {
        int x = 1;
        int y = 2;
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        swap(&x, &y);
    
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        return 0;
    }
    

    运行结果:

    x = 1, ptr = 000000000022FE4C
    y = 2, ptr = 000000000022FE48
    swap enter
    a = 1, ptr = 000000000022FE4C
    b = 1, ptr = 000000000022FE48
    a = 2, ptr = 000000000022FE4C
    b = 1, ptr = 000000000022FE48
    swap leave
    x = 2, ptr = 000000000022FE4C
    y = 1, ptr = 000000000022FE48
    

    结果表明:
    swap函数内部a b的数值进行交换,外部的x y的值也发生了交换。swap函数形参a b所指向的内存地址和外部x y的地址分别都相同。
    实质是:
    swap函数形式参数其实是一个指针,可能把fun(int *a)写成fun(int* a)就比较容易理解了,形参a为地址指针。*a就是xa就是&x。函数内部要想修改其数值就要使用*a取数值,打印其地址直接打印a就可以了。
    函数内部对a b的操作实际上是操作x y所在的内存空间,所以函数内的修改会影响到外部x y的数值。

    引用传递

    引用传递的形参加一个&符号,这个形参相当于实参的一个别名,对形参的操作都相当于对实参的操作。
    注意形参带&符号的引用传递在C语言中是不可用的,只有C++中支持。
    C语言中函数参数总是通过值传递,可以通过显式传递指针值模拟引用传递。

    Function parameters are always passed by value. Pass-by-reference is simulated in C by explicitly passing pointer values. – https://en.wikipedia.org/wiki/C_(programming_language)

    示例:

    #include <stdio.h>
    
    void swap(int &a, int &b){
        printf("swap enter\n");
        printf("a = %d, ptr = %p\n", a, &a);
        printf("b = %d, ptr = %p\n", a, &b);
    
        int tmp = b;
        b = a;
        a = tmp;
    
        printf("a = %d, ptr = %p\n", a, &a);
        printf("b = %d, ptr = %p\n", b, &b);
        printf("swap leave\n");
    }
    
    int main() {
        int x = 1;
        int y = 2;
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        swap(x, y);
    
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        return 0;
    }
    

    运行结果:

    x = 1, ptr = 000000000022FE4C
    y = 2, ptr = 000000000022FE48
    swap enter
    a = 1, ptr = 000000000022FE4C
    b = 1, ptr = 000000000022FE48
    a = 2, ptr = 000000000022FE4C
    b = 1, ptr = 000000000022FE48
    swap leave
    x = 2, ptr = 000000000022FE4C
    y = 1, ptr = 000000000022FE48
    

    结果表明:
    函数内对形参的使用方式和值传递相同,产生的效果和指针传递相同。
    swap函数内部a b的数值进行交换,外部的x y的值也发生了交换。swap函数形参a b所指向的内存地址和外部x y的地址分别都相同。

    实质是:
    形式参数前加&符号,这个形参相当于实参的一个别名,对这个形参的操作等同于对实参的操作,有点类似快捷方式。a等同于x,比如fun(int &a)函数内对a的操作和值传递的函数fun(int a)中对形参的操作一样,但是修改形参同时也是修改实参。

    展开全文
  • c语言和c++中值传递、指针传递和引用传递的比较和区别

    c语言和c++中值传递、指针传递和引用传递的比较和区别:

    值传递:

    形参是实参的拷贝,改变形参的值并不会影响外部实参的值。从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能传入,

    不能传出。当函数内部需要修改参数,并且不希望这个改变影响调用者时,采用值传递。

    指针传递:

    形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作

    引用传递:

    形参相当于是实参的“别名”,对形参的操作其实就是对实参的操作,在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈

    中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过

    栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

     1 #include<iostream>
     2 using namespace std;
     3 //值传递
     4  void change1(int n){
     5     cout<<"值传递--函数操作地址"<<&n<<endl;         //显示的是拷贝的地址而不是源地址 
     6     n++;
     7 }
     8 
     9 //引用传递
    10 void change2(int & n){
    11     cout<<"引用传递--函数操作地址"<<&n<<endl; 
    12     n++;
    13 }
    14  //指针传递
    15 void change3(int *n){
    16      cout<<"指针传递--函数操作地址 "<<n<<endl; 
    17     *n=*n+1;
    18  } 
    19 int     main(){
    20     int n=10;
    21     cout<<"实参的地址"<<&n<<endl;
    22     change1(n);
    23     cout<<"after change1() n="<<n<<endl;
    24     change2(n);
    25     cout<<"after change2() n="<<n<<endl;
    26     change3(&n);
    27     cout<<"after change3() n="<<n<<endl;
    28     return true;
    29 }
    运行结果:

    可以看出,实参的地址为0x22ff44

    采用值传递的时候,函数操作的地址是0x22ff20并不是实参本身,所以对它进行操作并不能改变实参的值

    再看引用传递,操作地址就是实参地址 ,只是相当于实参的一个别名,对它的操作就是对实参的操作

    接下来是指针传递,也可发现操作地址是实参地址

    指针传递和引用传递:

    C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的:

    指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)

    而在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。



    展开全文
  • C语言中值传递、指针传递和引用传递

    千次阅读 多人点赞 2018-07-07 19:42:12
    在C语言中值传递、指针传递和引用传递这三种函数参数传递方式是比较基本的知识,用的比较普遍,但不仔细分析其实质的话,时间长容易记混了。网上的资料也较多但多数都不系统,本文力求用最白话的表达和简单的示例把...


    在C语言中值传递、指针传递和引用传递这三种函数参数传递方式是比较基本的知识,用的比较普遍,但不仔细分析其实质的话,时间长容易记混了。网上的资料也较多但多数都不系统,本文力求用最白话的表达和简单的示例把这三种方式描述清楚。没时间看分析的直接看简述就可以了。

    简述

    值传递就是最普通的传递方式,比如函数定义为fun(int a),在调用的地方有int x=6, 使用fun(x)就可以了。这种方式在fun(int a)函数内部的对a的修改 不能 导致外部x的变化。 
    - 指针传递其实也就是地址传递,函数定义为fun(int *a),形参为指针,这就要求调用的时候传递进去一个参数的地址,例如int x=6; fun(&x)。 这种方式在fun(int a)函数内部的对a的修改  导致外部x的变化。 
    - 引用传递相比前两种方式用的比较少,但也非常有用。引用传递函数定义为fun(int &a),这里&符号是引用而不是取地址的意思,调用方式和值传递类似,例如int x=6; fun(x)。 但是这种方式在fun(int a)函数内部的对a的修改  导致外部x的变化。

    表格是一种比较直接的表达方式,列个表格可以对这三种方式一目了然,假设调用fun函数之前都有定义int x=6,这三种方式异同如下表所示:

    传递方式函数定义函数调用函数内对a修改的影响
    值传递fun(int a)fun(x)外部x不变
    指针传递fun(int *a)fun(&x)外部x同步更改
    引用传递fun(int &a)fun(x)外部x同步更改

    分析

    下面三部分代码都尝试在swap函数内对输入参数进行数值交换,通过打印其数值和指针来分析。

    值传递

    函数内部使用这个参数,对这个参数的修改对函数外的原始数据不起作用。

    示例:

    #include <stdio.h>
    
    void swap(int a, int b){
        printf("swap enter\n");
        printf("a = %d, ptr = %p\n", a, &a);
        printf("b = %d, ptr = %p\n", a, &b);
    
        int tmp = b;
        b = a;
        a = tmp;
    
        printf("a = %d, ptr = %p\n", a, &a);
        printf("b = %d, ptr = %p\n", b, &b);
        printf("swap leave\n");
    }
    
    int main() {
        int x = 1;
        int y = 2;
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        swap(x, y);
    
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    运行结果:

    x = 1, ptr = 000000000022FE4C
    y = 2, ptr = 000000000022FE48
    swap enter
    a = 1, ptr = 000000000022FE20
    b = 1, ptr = 000000000022FE28
    a = 2, ptr = 000000000022FE20
    b = 1, ptr = 000000000022FE28
    swap leave
    x = 1, ptr = 000000000022FE4C
    y = 2, ptr = 000000000022FE48
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    结果表明: 
    swap函数内部a b的数值进行交换,但是没有影响到x y的值。swap函数形参a b所指向的内存地址和外部x y的地址不一样。 
    实质: 
    swap为形式参数 a b创建了内存空间,main函数调用swap函数的时候,把x y的值copy给新创建的 a b 。a bx y分别在不同的内存位置中,因而对这个新创建的 a b 操作不会影响外部的 x y的值。

    带有返回值的函数,比如int fun(){int x=7; return x},外部调用方式为int a=fun();,这时是把x的数值copy了一份给外部a所在的内存空间,并释放了x所在的内存空间(系统自动分配的栈内存),在fun函数调用后即使知道x的内存地址也可能取不到相应的数据。 
    返回值为指针的函数,比如char *fun(){...; return str;},函数中待返回的变量必须是使用malloc等函数手动申请空间(堆内存)的数据,且外部使用后要手动释放。因为系统自动申请的栈内存会在函数调用后自动释放。

    指针传递(地址传递)

    形参为指向实参地址的指针,当对形参的指向操作时,就相当于操作实参本身。

    示例:

    #include <stdio.h>
    
    void swap(int *a, int *b){
        printf("swap enter\n");
        printf("a = %d, ptr = %p\n", *a, a);
        printf("b = %d, ptr = %p\n", *a, b);
    
        int tmp = *b;
        *b = *a;
        *a = tmp;
    
        printf("a = %d, ptr = %p\n", *a, a);
        printf("b = %d, ptr = %p\n", *b, b);
        printf("swap leave\n");
    }
    
    int main() {
        int x = 1;
        int y = 2;
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        swap(&x, &y);
    
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    运行结果:

    x = 1, ptr = 000000000022FE4C
    y = 2, ptr = 000000000022FE48
    swap enter
    a = 1, ptr = 000000000022FE4C
    b = 1, ptr = 000000000022FE48
    a = 2, ptr = 000000000022FE4C
    b = 1, ptr = 000000000022FE48
    swap leave
    x = 2, ptr = 000000000022FE4C
    y = 1, ptr = 000000000022FE48
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    结果表明: 
    swap函数内部a b的数值进行交换,外部的x y的值也发生了交换。swap函数形参a b所指向的内存地址和外部x y的地址分别都相同。 
    实质是: 
    swap函数形式参数其实是一个指针,可能把fun(int *a)写成fun(int* a)就比较容易理解了,形参a为地址指针。*a就是xa就是&x。函数内部要想修改其数值就要使用*a取数值,打印其地址直接打印a就可以了。 
    函数内部对a b的操作实际上是操作x y所在的内存空间,所以函数内的修改会影响到外部x y的数值。

    引用传递

    引用传递的形参加一个&符号,这个形参相当于实参的一个别名,对形参的操作都相当于对实参的操作。

    示例:

    #include <stdio.h>
    
    void swap(int &a, int &b){
        printf("swap enter\n");
        printf("a = %d, ptr = %p\n", a, &a);
        printf("b = %d, ptr = %p\n", a, &b);
    
        int tmp = b;
        b = a;
        a = tmp;
    
        printf("a = %d, ptr = %p\n", a, &a);
        printf("b = %d, ptr = %p\n", b, &b);
        printf("swap leave\n");
    }
    
    int main() {
        int x = 1;
        int y = 2;
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        swap(x, y);
    
        printf("x = %d, ptr = %p\n", x, &x);
        printf("y = %d, ptr = %p\n", y, &y);
    
        return 0;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    运行结果:

    x = 1, ptr = 000000000022FE4C
    y = 2, ptr = 000000000022FE48
    swap enter
    a = 1, ptr = 000000000022FE4C
    b = 1, ptr = 000000000022FE48
    a = 2, ptr = 000000000022FE4C
    b = 1, ptr = 000000000022FE48
    swap leave
    x = 2, ptr = 000000000022FE4C
    y = 1, ptr = 000000000022FE48
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    结果表明: 
    函数内对形参的使用方式和值传递相同,产生的效果和指针传递相同。 
    swap函数内部a b的数值进行交换,外部的x y的值也发生了交换。swap函数形参a b所指向的内存地址和外部x y的地址分别都相同。

    实质是: 
    形式参数前加&符号,这个形参相当于实参的一个别名,对这个形参的操作等同于对实参的操作,有点类似快捷方式。a等同于x,比如fun(int &a)函数内对a的操作和值传递的函数fun(int a)中对形参的操作一样,但是修改形参同时也是修改实参。

    展开全文
  • 详细介绍了C++中通过指针和通过引用传递参数的区别
  • 区别1:指针传递和引用传递是以不同的方式实现相同的效果,但是指针传递的本质还是值传递,只是传递的值是地址。 就拿 交换两个数的函数来举例: // 指针传递 void swap(int * val1, int * val2) { int temp...

    区别1:指针传递和引用传递是以不同的方式实现相同的效果,但是指针传递的本质还是值传递,只是传递的值是地址。

    就拿 交换两个数的函数来举例:

    // 指针传递
    void swap(int * val1, int * val2)
    {
        int temp;
        temp = *val1;
        *val1 = *val2;
        *val2 = temp;
    }
    
    
    // 引用传递
    void swap_numbers(int & val1,int & val2)
    {
        int temp;
        temp = val1;
        val1 = val2;
        val2 = temp;
    }

    调用上面两个函数都可以实现 val1 和 val2 的值的交换。

    int first = 1, second = 2;
    
    swap_numbers(first,second); // 传递引用,也就是别名
    
    int a,b;
    
    swap(&a,&b); // 传递指针,也就是地址

    但是,归根到底,指针是储存了值的地址的值也还是实现了值传递

    而引用传递,传入的是变量名称,相当于在交换函数内部使用了外部变量的别名,操作的依然是变量本身。

     

    区别2:指针传递相对于引用传递更灵活,也就更不受约束。

    如果把引用传递类比为指针传递开辟了新的变量存储了别名的相关信息的话,那么,指针传递的地址的值是可变的,同时,该地址空间中存储的值也是可变的;而引用传递却是和别名是捆绑,不可再指向其他的地址空间的。

    引用本质上就是一个 const 指针,但是两者有一定的差别,不能互换使用。 

     

    总之,引用传递作为 C++ 区别于 C 语言的一种特性,使得传参更为灵活,方便,还避免了指针使用易出错的情况。

     

    详细的引用传递和指针传递的引用可以 参考博客

    C++中引用传递与指针传递区别(进一步整理) - - ITeye博客

    转载于:https://www.cnblogs.com/yqmcu/p/10368745.html

    展开全文
  • C++函数参数和返回值三种传递方式:值传递、指针传递和引用传递 (着重理解)引用与指针的比较引用是 C++中的概念,初学者容易把引用和指针混淆一起。一下程序中,n 是m 的一个引用(reference),m 是被引用物...
  • C++中值传递、指针传递和引用传递的比较 C++引用与指针的比较 引用是C++中的概念,初学者容易把引用和指针混淆一起。 一下程序中,n是m的一个引用(reference),m是被引用物(referent)。 int m; int &n = m;...
  • C++函数参数和返回值三种传递方式:值传递、指针传递和引用传递(着重理解) 引用与指针的比较 引用是 C++中的概念,初学者容易把引用和指针混淆一起。一下程序中,n 是m 的 一个引用(reference),m 是被引用物...
  • 引用是C++中的概念,初学者容易把引用和指针混淆一起。  一下程序中,n是m的一个引用(reference),m是被引用物(referent)。  int m;  int &n = m;  n相当于m的别名(绰号),对n的任何操作就是对m的操作...
  • 毫无疑问,作为以C语言为基础,和C语言同一个爹的一门编程语言,C++自然与C原因有很多相似之处,例如C++的变量传递就沿用了C语言中的值传递和指针传递两种。此外,C++还引入了一种新的传递方式——引用传递。下面...
  • 上题是考察函数的值传递、指针传递(地址传递)以及引用传递。 二、值传递 形参是实参的拷贝,改变形参的值并不会影响外部实参的值 。从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能...
  • 传递:形参是实参的拷贝,改变形参的值并不会影响外部实参的值。从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能传入,不能传出。当函数内部需要修改参数,并且不希望这个改变影响调用者时,...
  • 文章目录1 C++ 值传递、指针传递引用传递详解值传递:指针传递引用传递:2 数组作为函数的形参2.1 一维数组传递2.2 二维数组传递总结 1 C++ 值传递、指针传递引用传递详解 值传递: 形参是实参的拷贝,改变...
  • 另一方面,值传递由于形参实参内存地址不一样,有些功能并不能实现(swap()),因此,除了极为简单的函数会使用值传递外,大多数会采用引用传递。而对于指针传递,则在涉及数组的情况下使用较多,因为指针本身会给...
  • 了解值传递/指针传递/引用传递的使用方法。
  • C++ 值传递、指针传递引用传递详解 最近写了几篇深层次讨论数组指针的文章,其中提到了“C语言中,所有非数组的形式参数传递均以值传递形式” 数组指针背后——内存角度 语义"陷阱"---数组...
  • 指针传递传递 这张图片我们可以看出head指针的地址与head指针所指向的内容的地址也就是值的地址如下图: 继续Debug 显而易见p指针所在的地址与head不同 说明了什么? 说明了当指针作为函数参数传递指针其实就是值...
  • 关于指针传递和指针引用传递

    千次阅读 2017-12-04 14:27:29
    指针传递的实质: 指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为...
  • 1.值传递 值传递的意思就是把实际参数的值传递给对应的形式参数,形式参数接收的是实际参数的一个副本,在方法内部操作的是形参而非实参,其值的改变并不影响实参。 2.引用传递 ...3.指针传递 C++
  • 1. 值传递 形参是实参的拷贝,改变形参的...2.指针传递 指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变其指向的地址中所存放的数据的改变。 3.引用传递 引用
  • 值传递,指针传递,引用传递 的区别 值传递: 从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能传入,不能传出 形参为实参的拷贝,形参有单独的内存空间,当函数内部需要修改参数,并且不...
  • C++函数的三种传递方式为:值传递、指针传递和引用传递值传递:void fun(int x){ x += 5; //修改的只是y在栈中copy x,x只是y的一个副本,在内存中重新开辟的一块临时空间把y的值 送给了x;这样也增加了程序运行的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 249,626
精华内容 99,850
关键字:

指针传递和引用传递