精华内容
下载资源
问答
  • 主要介绍了C++中引用传递指针传递的区别(面试常见),需要的朋友可以参考下
  • 文章目录1 C++ 值传递指针传递引用传递详解值传递指针传递引用传递:2 数组作为函数的形参2.1 一维数组传递2.2 二维数组传递总结 1 C++ 值传递指针传递引用传递详解 值传递: 形参是实参的拷贝,改变...

    1 C++ 值传递、指针传递、引用传递详解

    值传递:

    形参是实参的拷贝,改变形参的值并不会影响外部实参的值。从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能传入,不能传出。当函数内部需要修改参数,并且不希望这个改变影响调用者时,采用值传递。

    指针传递:

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

    引用传递:

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

    下面的代码对此作出细致解释(从实参,形参在内存中存放地址的角度 说明了问题的本质,容易理解 )

    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    #include<iostream>
    using namespace std;
    //值传递
    void change1(int n){
        cout<<"值传递--函数操作地址"<<&n<<endl;         //显示的是拷贝的地址而不是源地址
        n++;
    }
    
    //引用传递
    void change2(int & n){
        cout<<"引用传递--函数操作地址"<<&n<<endl;
        n++;
    }
    //指针传递
    void change3(int *n){
        cout<<"指针传递--函数操作地址 "<<n<<endl;
        *n=*n+1;
    }
    int main(){
        int n=10;
        cout<<"实参的地址"<<&n<<endl;
        change1(n);
        cout<<"after change1() n="<<n<<endl;
        change2(n);
        cout<<"after change2() n="<<n<<endl;
        change3(&n);
        cout<<"after change3() n="<<n<<endl;
        return true;
    }
    

    在这里插入图片描述
    引用的规则:

    (1)引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。
    (2)不能有NULL引用,引用必须与合法的存储单元关联(指针则可以是NULL)。
    (3)一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。

    参考链接:https://www.cnblogs.com/yanlingyin/archive/2011/12/07/2278961.html

    2 数组作为函数的形参

    2.1 一维数组传递

    然而,由于在C和C++中数组不能直接复制,传递时只传递一个首地址,在函数中需要使用的时候再跟据首地址和下标去寻找对应的值。
    至于为何数组不能直接复制,有一种解释的说法:

    • 是为了避免不必要的复制开销,因为数组的复制将导致连续的内存读与内存写,其时间开销取决于数组长度,有可能会变得非常大。为了避免复制数组的开销,才用指针代替数组。因此C语言使得当数组作为实参传递给函数的时候,将退化为同类型的指针,再传递指针的值。
      因此,在函数中修改数组值时,修改的是真的值。
    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    #include<iostream>
    using namespace std;
    //值传递
      void printdz(int a[])
      {
      	cout<<"子函数里a0的地址为"<<&a[0]<<endl;
      	cout<<"子函数里a的地址为"<<a<<endl; //a本身即为指针 无需取地址符
      	cout<<"子函数里a1的首地址为"<<&a[1]<<endl;
      	a[1]=2;
      }
      int main()
      {
        int a[10]={1};
        cout<<"主函数里a的首地址为"<<&a[0]<<endl;
      	cout<<"开始的a1为 "<<a[1]<<endl;
      	printdz(a);
      	cout<<"函数里改过的a1 为"<<a[1]<<endl;
      	return 0;
      }
    
    

    在这里插入图片描述

    • 在这里我们可以看到子函数里的首地址a[0]与主函数的首地址是相同的。
    • a已经是一个指针了。由于是通过指针传递,因此无法得到数组的长度

    除了退化为指针传递,还可以直接通过指针传递和通过引用传递。

    指针传递:

    void printdzyy(int *aa) //传入指针 or void printdzyy(int aa[])
    {
    	cout<<"函数里参数的地址为"<<&aa[0]<<endl;
    }
    int main()
    {
      int a[10]={1};
    	int b[5]={1};
      cout<<"主函数里a[0]的首地址为"<<&a[0]<<endl;
    	printdzyy(a);
      printdzyy(b);//传入指针时 编译器无法知道数组长度 因此可以随便传
    	return 0;
    }
    

    在这里插入图片描述

    通过引用传递::

    void printdzyy(int (&aa)[10]) //引用就可以传递数组长度 因此需要写出数组大小
    {
    	cout<<"函数里aa的地址为"<<aa<<endl;
    }
    int main()
    {
      int a[10]={1};
    	int b[5]={1};
      cout<<"主函数里a[0]的首地址为"<<&a[0]<<endl;
    	printdzyy(a);
      //printdzyy(b);  incorrect  //如果传入b则编译不通过
    	return 0;
    }
    

    在这里插入图片描述

    • 从上述程序可以知道,传入指针时,编译器无法知道数组长度,因此可以传递进去不同长度的数组,也可以不写出数组长度。
    • 但是传递引用时,同时将数组长度也传递进去了,所以传入时必须为相应长度的数组。并且,在传递引用时,需要注意用()将&aa括起来,否则编译器报错。
    • 对于引用,也叫“别名”,某种意义上可作为无地址的指针,相比指针,引用不存在地址,必须被初始化,不存在NULL,不可改变对象,引用无法被多重引用。因此更加安全

    2.2 二维数组传递

    可以理解为数组的定义等同于指针的定义,即*a等同于a[],因此可以作如下变换

    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    //1.5
    void func1(int iArray[][10])  //等同于 void func1(int (*iArray)[10])
    {
    }  //等同于void func1(int iArray[10][10])
    int main()
    {
        int array[10][10];
        func1(array);
    }
    
    

    注意(iAarray)可通过,去掉括号会编译错误*

    由于二维数组在栈内分配的内存是连续的,需要告诉编译器偏移的点,所以第二维度不可省,必须符合,而第一维度如一维数组一样随意。因此在上述代码1.5 中void func1(int iArray[9][10])不会报错,而void func1(int iArray[10][9])会报错。

    同一维数组,这边推荐使用引用,使用引用时需要保证两个维度都要ok:

    //1.6
    void func3(int (&pArray)[10][10])  
    {  }  
    int main()  
    {  
        int array[10][10];  
        func3(array);  
    }  
    

    也可以指针的指针来表示二维数组,动态分配内存的形式,此时,严格来说,并不是二维数组。

    #include <iostream>
    #include <stdio.h>
    void out(double **a,int m, int n)
    {
        int i, j;
        double b=0.0;
        for(i=0; i<m; i++)
        {for (j=0; j<n; j++)
            {
                a[i][j] = b;
                b += 1.2;
                printf("%5.1f",a[i][j]);
            }
            std::cout << std::endl; }   
    }
    int main(int argc, char * agrv)
    {
        int i, j, m=2, n=3;
        double **a;
        a = new double*[m];
        for (i=0; i<m; i++)
            a[i] = new double[n];
        out(a,m,n);
        return 1;
    }
    
    

    总结

    在传递数组参数时,首要推荐通过引用来传递参数,精准传入数组大小值,函数中参数定义为
    vtype (&name)[size][size],引用时传入名字即可。

    在通过指针传递时,需要另外传入参数来传递数组的大小。

    参考:
    https://blog.csdn.net/qq_30600259/article/details/101551220
    https://blog.csdn.net/desilting/article/details/7983530

    展开全文
  • 最近上数据结构课程,学习了线性表的基本实现方法和操作,但是在实现过程中,遭遇了有的函数在形参里面使用的是线性表的指针Sqlist*L,有的则是使用的是线性表的指针引用Sqlist*& L,对此,我进行了一点自己的...
    引言

    最近上数据结构课程,学习了线性表的基本实现方法和操作,但是在实现过程中,遭遇了有的函数在形参里面使用的是线性表的指针Sqlist*L,有的则是使用的是线性表的指针的引用Sqlist*& L,对此,我进行了一点自己的探究,以及总结了什么时候该使用指针,什么时候该使用指针的引用

    1. 指针

    指针是C++里面一种常用的类型,它由C语言继承而来,用来存储对象的地址。
    通过指针,我们可以访问它所指向的位置的元素,以及对它解引用。

    2. 引用

    引用是C++一种特殊的类型,它用来指向某个对象,换句话说,引用就是它指向对象的别名
    引用区别于指针的地方是,引用没有存储空间,只是把这个原来的空间重命名成为了引用名。

    3. 值传递(pass by value)和引用传递(pass by reference)
    • 值传递指的是变量作为参数进行传递,在传入实参过后,实参实际上是在函数作用域里面新建了一个局部变量,它的值和原来的参数内容完全相同,所以不能够通过这个函数修改这个变量。
    • 引用传递指的是引用作为参数进行传递,这里引用就是原来本身的变量,在函数中,调用这个引用也就相当于访问了原来的那个地址,可以对原本的对象进行修改。
    4. 指针的引用

    在顺序表的销毁操作,代码如下

    void Destroy(Sqlist*& L)
    {
    free(L);
    L=NULL;//能够修改L的地址
    }
    
    void Destroy(Sqlist* L)
    {
    free(L);
    L=NULL;//不能更改L的地址,只能在函数作用域内更改局部变量L
    }
    

    如果希望将L的地址改变,就需要传入指针的引用,如果只是需要释放内存,那么指针也可。
    因为指针的引用是原来的那个L的实参,而指针只是在函数体里面拷贝的一个L的地址作为局部变量,任何试图更改L的地址讲无效

    展开全文
  • 另一方面,值传递由于形参和实参内存地址不一样,有些功能并不能实现(swap()),因此,除了极为简单的函数会使用值传递外,大多数会采用引用传递。而对于指针传递,则在涉及数组的情况下使用较多,因为指针本身会给...
  • 但 是对于传递指针应用,如果将传递进来的指针指向了新的对象,那么原始的指针也就指向了新的对象,这样就会造成内存泄漏,因为原来指针指向的地方已经不能再 引用了,即使没有将传递进来的指针指向新的对象,而是在...

    如果是传递指针,那么会先复制该指针,在函数内部使用的是复制后的指针,这个指针与原来的指针指向相同的地址,如果在函数内部将复制后的指针指向了另外的新的对象,那么不会影响原有的指针;
    但 是对于传递指针应用,如果将传递进来的指针指向了新的对象,那么原始的指针也就指向了新的对象,这样就会造成内存泄漏,因为原来指针指向的地方已经不能再 引用了,即使没有将传递进来的指针指向新的对象,而是在函数结束的时候释放了指针,那么在函数外部就不能再使用原有的指针了,因为原来的内存已经被释放了

     

    看个例子:

    #include <cstdlib>
    #include <cstring>
    #include <memory>
    #include <iostream>

    using namespace std;

    void func2(char *str)
    {
        str = (char *)malloc(10);
        strcpy(str, "hello");
    }

    void func3(char *&str)
    {
        str = (char *)malloc(10);
        strcpy(str, "hello");
    }
    int main()
    {
        char *str = "1234567890";

        func2(str);
        cout << str << endl;
        func3(str);
        cout << str << endl;
    }

    程序输出:

    1234567890
    hello

     

    简单一点可以这么想,如果不用引用的话,被传递的参数本身是不能被修改的, 
    即使你传递的是指针,也不过能修改指针指向的内容,不能修改指针本身。 

    如果要修改当前被传递的参数的话,要么再加一级指针,要么用引用。

    指针的引用类似于二级指针

    传递指针的话,在函数体内你只能修改指针的内容,不能改变指针本身(非const type *类型,指针本身也能修改的,只是这个修改,不会影响到实参指针) 
    传递指针的引用,在函数体内,你既可以修改指针的内容,也可以修改指针本身(实参)

    有区别, 
    无论你传值还是传指针,函数都会生成一个临时变量, 但传引用时,不会生成临时变量, 当你传值时,只可以引用值而不可以改变值,但传值引用时,可以改变值, 当你传指针时,只可以改变指针所指的内容,不可以改变指针本身,但传指针引用时,即可以改变指针所指的内容,又可以改变指针本身,但传引用主要是它不生成临时变量,不进行返回值copy等,速度快。



    从概念上讲。指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

    而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量)。

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

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

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

    引用传递和指针传递是不同的,虽然它们都是在被调函数栈空间上的一个局部变量,但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数,如果改变被调函数中的指针地址,它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量,那就得使用指向指针的指针,或者指针引用。

    为了进一步加深大家对指针和引用的区别,下面我从编译的角度来阐述它们之间的区别:

    程序在编译时分别将指针和引用添加到符号表上,符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值,而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改,因此指针可以改变其指向的对象(指针变量中的值可以改),而引用对象则不能修改。

    最后,总结一下指针和引用的相同点和不同点:

    ★相同点:

    ●都是地址的概念;

    指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名。

    ★不同点:

    ●指针是一个实体,而引用仅是个别名;

    ●引用只能在定义时被初始化一次,之后不可变;指针可变;引用“从一而终”,指针可以“见异思迁”;

    ●引用没有const,指针有constconst的指针不可变;

    ●引用不能为空,指针可以为空;

    ●“sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身的大小;

    ●指针和引用的自增(++)运算意义不一样;

    ●引用是类型安全的,而指针不是 (引用比指针多了类型检查

    展开全文
  • 详细介绍了C++中通过指针和通过引用传递参数的区别
  • 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代码实现指针参数的引用传递,使得函数中的修改得以保存,请问InTread()内的参数应该写成什么样的形式?注:下面的代码可能需要进一步修正;ThreadTree为结构体指针 ...
  • C++ 值传递指针传递引用传递详解 最近写了几篇深层次讨论数组和指针的文章,其中提到了“C语言中,所有非数组的形式参数传递均以值传递形式” 数组和指针背后——内存角度 语义"陷阱"---数组和...
  • 为什么 Java 只有值传递,但 C++ 既有值传递,又有引用传递呢?今天我们就来探讨下这个问题,有需要的朋友可以参考下
  • 指针有时候真的不是很好懂下面下面我将利用调试的方式讲解一下指针到底是个什么东西 这里我使用了链表结构题 ...说明了当指针作为函数参数传递指针其实就是值传递(也就是把head拷贝一份)如下图: ...
  • 传递: 形参是实参的拷贝,改变形参的值并不会影响外部实参的值。从被调用函数的角度来说,值传递是单向的(实参-&gt;形参),赋值完毕后实参就和形参没有任何联系。当函数内部需要修改参数,并且不希望这个...
  • 关于指针传递指针引用传递

    千次阅读 2017-12-04 14:27:29
    指针传递的实质: 指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为...
  • C语言中值传递指针传递引用传递

    千次阅读 多人点赞 2018-07-07 19:42:12
    在C语言中值传递指针传递引用传递这三种函数参数传递方式是比较基本的知识,用的比较普遍,但不仔细分析其实质的话,时间长容易记混了。网上的资料也较多但多数都不系统,本文力求用最白话的表达和简单的示例把...
  • 1.值传递传递的意思就是把实际参数的值传递给对应的形式参数,形式参数接收的是实际参数的一个副本,在方法内部操作的是形参而非实参,其值的改变并不影响实参。 2.引用传递 ...3.指针传递 C++
  • C++中引用传递指针传递的区别

    万次阅读 多人点赞 2018-06-25 19:16:40
    精简版:指针:变量,独立,可变,可空,替身,无类型检查;引用:别名,依赖,不变,非空,本体,有类型检查;完整版:1. 概念 指针从本质上讲是一个变量,变量的值是另一个变量的地址,指针在逻辑上是独立的,它...
  •  值传递是指在调用函数时将实际参数复制一份传递到函数中,这样在函数中如果对参数进行修改,将不会影响到实际参数  声明一个值类型变量时,编译器会在栈中分配一个空间,空间里存储的就是该变量的值  go语言...
  • 区别1:指针传递引用传递是以不同的方式实现相同的效果,但是指针传递的本质还是值传递,只是传递的值是地址。 就拿 交换两个数的函数来举例: // 指针传递 void swap(int * val1, int * val2) { int temp...
  • 【Qt】信号和槽对值传递参数和引用传递参数的总结 在同一个线程中 当信号和槽都在同一个线程中时,值传递参数和引用传递参数有区别: 值传递会复制对象;(测试时,打印传递前后的地址不同) 引用传递不会复制对象...
  • 原文地址: ...值传递:形参是实参的拷贝,改变形参的值并不会影响外部实参的值。从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能传入,不能传出。...指针传递:形参为指向实参地址的指针,当对
  • 引用传递指针传递区别

    千次阅读 2017-11-13 20:18:00
    #include using namespace std; //值传递 void change1(int n){ ...//引用传递 void change2(int & n){ cout n++; } //指针传递 void change3(int *n){ cout *n=*n+1; } int main(){ int n=10;
  • cpp代码-函数返回值:值传递 指针传递 引用传递 (返回值 返回指针 返回引用) int Fun(int a); int *Fun(int a); int &Fun(int a); (别名)
  • Go语言中函数的参数有两种传递方式,按值传递和按引用传递。Go默认使用按值传递传递参数,也就是传递参数的副本。在函数中对副本的值进行更改操作时,不会影响到原来的变量。 按引用传递其实也可以称作”按值传递...
  • C++ 整形 值传递 引用传递 指针传递
  • http://blog.csdn.net/yusiguyuan/article/details/12357381 ... 而关于值传递指针传递引用传递这几个方面还会存在误区, 所有我觉的有必要在这里也说明一下~ 下文会通过例子详细说明哦 值传递: 形参是实参的
  • 指针传递参数的本质是值传递,只不过它传递的是一个地址值,函数执行的时候在栈中创建并拷贝实参的地址值。函数可以根据地址,找到地址指向的内存单元。因而可以改变主函数实参指向的变量的值。 如果要数据对象...
  • 引用是C++中的概念,初学者容易把引用指针混淆一起。  一下程序中,n是m的一个引用(reference),m是被引用物(referent)。  int m;  int &n = m;  n相当于m的别名(绰号),对n的任何操作就是对m的操作...
  • 指针传递、地址传递引用传递

    千次阅读 2018-08-26 09:32:40
    一、指针的值传递 //test.c #include &lt;cstdio&gt; #include &lt;cstring&gt; #include &lt;cassert&gt; void fun(char* p){ p = (char*)malloc(sizeof(char)); assert(p!=NULL); ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 250,132
精华内容 100,052
关键字:

传递指针的引用