C++笔记——参数传递中的指针传递和引用传递

C++笔记——参数传递中的指针传递和引用传递

引用和指针的不同点

C/C++ | 三种不同函数参数传递方式 （***）

C++学习——引用、传值和传引用的效率对比、引用与指针

C++函数返回引用 问题1

C++ 引用作为函数返回值 问题2

----------------------------------------------------------------------

函数返回引用，以引用作为参数 的区别：

1. 被调用函数的返回值为引用变量：在该被调用函数内部的引用返回变量，不能使用局部变量。

2. 引用作为函数参数：在主调用函数内部的变量，可以是局部变量。

3. 值返回，更简单。但是，当同时需要返回 2个及以上的参数时，则可使用多个的 引用参数。

主调用函数的局部变量，可以作为被调用函数的引用型参数传入。

主调用函数的局部变量，并不能作为被调用函数的引用型返回值来使用；

这是作用域问题，即被调用函数，不能使用主调用函数的局部变量。

被调用函数的引用型返回值，不能使用自己的局部变量，来作为返回值。

生存期问题。

4. “引用”的本质 ？

4.1. 属于“构造型变量”，由编译器在编译过程中进行构造。

4.2. 特点

4.2.1. 不能独立存在。属于一种虚拟的、“构造型变量”，需要依附于真正的变量而存在。

4.2.2. 像指针，引用指向真正的变量。但不是指针，因为其用法和普通变量类似。

4.2.3. 像变量，用法和普通变量类似。但引用指向的是却同一份内存地址，而不是变量的副本。

4.2.4. 变量的“别名”：用法上像变量，又包含有指针的特性。

4.3. 返回值为 引用的函数

4.3.1. 返回值为引用的被调用函数

这个引用型的返回值，不能是函数内部定义的栈变量（堆变量，可以？），对这种返回值的限制、颇多？

4.3.2. 在主调用函数中，直接设置一个类似专门接收函数返回值的引用参数，传个被调用函数。

这样，被调函数不需要采用有返回值的函数，而是直接将返回值，写入到接收返回值的引用当中，即可。

解决：函数的封装问题。

在被被调用函数内部，进行值得赋值；与函数返回值得方式，在主调用函数得内部进行值得赋值，似乎并不能够在性能上（占用内存，复制时间，其他）有所区别？

4.3.3. 在被调用函数中，这种“引用”，不可靠？

如能保证在使用之前，不会被改变，则ok。

但因为 value是局部变量，会被回收，因此，可能会被修改；不可靠 ？

4.3.4. 在 Qt中，函数的返回值为引用 时，自定义的数据类型需要注册。

如果不注册的话，作为引用参数，传入到（原本期望为具有返回值的标准型函数）被调用函数，是否有问题？

5. 指针

5.1. 在被调用函数中，new 指针。

int * abc =new int; //传回在被调用函数中定义的指针

在主调用函数中，应该需要 delect , 以防止内存泄漏。

int& abc(uint type)
{
    int value =0;
    int * testInt =new int;
    testInt =&value;

    //qDebug()<<"testInt === ::"<<testInt;

    if(type ==0)
    {
        value =  value +111;
        qDebug()<<"value 00 :: "<<value;
        return *testInt;
    }

============================================

C++ 引用作为函数返回值 问题2

  https://blog.csdn.net/a3192048/article/details/83277412

（1）以引用返回函数值，定义函数时需要在函数名前加 &

（2）用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。

引用作为返回值，必须遵守以下规则：

    （1）不能返回局部变量（在引用函数内部的局部变量）的引用。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。

解决：通过使用非局部变量的引用，对于非局部变量和函数捆绑在一起。

好处之一：对于需要使用非局部变量场景，可以解决函数的封装问题。

否则，非局部变量，太多的函数都可以直接使用它们。

C++ 引用作为函数的参数

好处：对于不需要常驻内存的局部变量，主调函数使用 局部变量来调用子函数；主函数退出，内存回收。

C++ 值传递

对于占用小字节的数据传递，简单。

不让指针飞。

为什么需要这么多不同的传递方式？

在不同的应用场景里，可以选用在该应用场景里的最佳实现方式。

是由于世界丰富多彩，使得在解决现实问题的时候，需要采用在不同应用场景之下的最佳工具而造成的。没有万能的工具，没有包治百病的药。

在理解这些概念的时候，不能将视角集中在编程语言的本身，而应该聚焦到需要解决文图的客观场景里；否则，本末导致，难以理解。

又如：覆盖/重写。这类概念是从外来语引入的，翻译很乱，有多个不同的翻译版本。假如直接从概念本身来理解的话，晕倒。

————————————————
版权声明：本文为CSDN博主「啊大1号」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/a3192048/article/details/83277412

C++函数返回引用 问题

  https://blog.csdn.net/qq_33266987/article/details/53516977

三、返回 this 指向的对象

        在类的成员函数中，返回引用的类对象，当然不能是函数内定义的类对象（会释放掉），一般为 this 指向的对象，典型的例子是 string类的赋值函数。

C++学习——引用、传值和传引用的效率对比、引用与指针

一、 引用

1.1 引用概念

        引用（reference）是为变量起了另一个名字，而不是定义一个新变量。编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。其使用形式如下：

        类型& 引用变量名(对象名) = 引用实体；

        eg:

    int ival = 1024;
    int &refVal = ival; // refVal 指向ival（是ival的另一个名字）
    int &refVal2;    // 报错：引用必须被初始化

      定义引用时，程序把引用和它的初始化绑定在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用将和它的初始值对象一直绑定在一起。因为无法令引用重新绑定到另外一个对象，所以引用必须初始化。注意：引用类型必须和引用实体是同种类型的。

1.2 引用的特性

           (1)  引用在定义式必须初始化；

         （2）一个变量可以有多个引用；

         （3）引用一旦引用一个实体，再不能引用其他实体；

1.3 引用的使用场景

     1 做参数

    void Swap(int& left, int& right)
    {
    int temp = left;
    left = right;
    right = temp;
    }

     2 做返回值

    int& Count()
    {
    static int n = 0；
    n++;
    // ...
    return n;
    }

       注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

注：没有 static：warning: reference to stack memory associated with local variable 'hash' returned

  例如下面代码就会出现问题。

    int& Add(int a, int b)
    {
        int c = a + b;
        return c;
    }
    int main()
    {
        int& ret = Add(1, 2);
        Add(3, 4);
        cout << "Add(1, 2) is :" << ret << endl;
        system("pause");
        return 0;
    }
     
     
    运行结果：
    Add(1, 2) is :7
    请按任意键继续. . .

           所以使用时注意作用域。

二、 传值和传引用的效率对比

    先用以下代码进行测试一下：

    #include <time.h>
    #include <iostream>
    using namespace std;
     
    struct A { int a[10000]; };
    void TestFunc1(A a) {}  // 传值
    void TestFunc2(A& a) {}  // 传引用
    A a;
    A Fun3() {
        return a;
    }
     
    A &Fun4() {
        return a;
    }
     
     
    void test1()
    {
        A a;
        // 以值作为函数参数
        size_t begin1 = clock();
        for (size_t i = 0; i < 100000; ++i)
            TestFunc1(a);
        size_t end1 = clock();
     
        // 以引用作为函数参数
        size_t begin2 = clock();
        for (size_t i = 0; i < 100000; ++i)
            TestFunc2(a);
        size_t end2 = clock();
        // 分别计算两个函数运行结束后的时间
        cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
        cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
     
        // 以值作为函数返回值
        size_t begin3 = clock();
        for (size_t i = 0; i < 100000; ++i)
            Fun3();
        size_t end3 = clock();
        // 以引用作为函数返回值
        size_t begin4 = clock();
        for (size_t i = 0; i < 100000; ++i)
            Fun4();
        size_t end4 = clock();
        // 分别计算两个函数运行结束后的时间
        cout << "Fun3 time:" << end3 - begin3 << endl;
        cout << "Fun4 time:" << end4 - begin4 << endl;
    }
     
    int main()
    {
     
        test1();
        system("pause");
        return 0;
    }
     
     
    运行结果:
    TestFunc1(A)-time:129    <-- 参数传值
    TestFunc2(A&)-time:2     <-- 参数传引用
    Fun3 time:336            <-- 返回值为值
    Fun4 time:2              <-- 返回值为引用
    请按任意键继续. . .

      从运行结果可见传引用比传值的效率高很多。因为，以值做为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
三、 引用和指针的区别

     在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。但是在底层实现上，引用是按指针的方式实现的。怎么体现呢，看汇编代码。如下：

    int main()
    {
        int a = 10;
        int& ra = a;
        ra = 20;
        int* pa = &a;
        *pa = 20;
        return 0;
    }

       将上面简单代码进行反汇编：

可见：

         在底层实现上：引用通过指针实现，定义一个引用类型变量相当于定义一个指针类型变量

         语法上： 引用是别名，不是指针，没有发生拷贝。

引用和指针的不同点:
     1. 引用在定义时必须初始化，指针没有要求
     2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
     3. 没有NULL引用，但有NULL指针
     4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
     5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
     6. 有多级指针，但是没有多级引用
     7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
     8. 引用比指针使用起来相对更安全
————————————————
版权声明：本文为CSDN博主「尼克选手」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_44132627/article/details/106356423

C/C++ | 三种不同函数参数传递方式 （***）

一、前言

本文介绍C/C++语言中三种函数参数传递方式：值传递、引用传递、指针传递，全文分为三个部分：“初识三种函数参数传递方式”“代码演示”“引用传递和指针传递的区别”。

初识三种函数参数传递方式：该部分用表格对比三种函数参数传递方式；

代码演示：该部分分为三个小节，分别用代码实现值传递、引用传递、指针传递；

引用传递和指针传递的区别：着重介绍引用传递和指针传递区别。

一起来看看吧！

二、初识三种函数参数传递方式

C/C++中存在三种函数参数传递方式，值传递、引用传递、指针传递。

注意：C语言中支持两种参数传递方式——值传递和指针传递，

C++中支持三种传递方式——值传递、引用传递和指针传递，

对于引用传递，C语言不支持，但是C++支持。

本节演示的程序是C++程序，因为C语言中引用传递无法演示出来。

三、代码演示

3.1 值传递（传值）

代码1：

#include<iostream>
using namespace std;
 
//值传递   交换前a=1,b=2;交换后a=1,b=2;
void swapByValue(int a,int b)
{
    cout<<"swapByValue函数  交换前"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
 
    int temp=a;
    a=b;
    b=temp;
    cout<<"swapByValue函数  交换后"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
}
 
//主函数
int main()
{
    int a=1;
    int b=2;
    cout<<"main函数  交换前"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    swapByValue(a,b);//值传递
    cout<<"main函数  交换后"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    return 0;
}

输出1：

小结1：可以看出main函数中a、b变量的内存地址和swap函数中a、b变量的内存地址没有任何关系。

因为它们本来就是两套独立的存储位置，相互之间没有任何关系，从main函数中调用swapByValue函数，是指将a、b参数的值传递过去，所以内存地址为0xfafed0、0x6afed4的a、b变量的值的变化不会影响到内存地址0xfafeec、0x6afee8的a、b变量的值。

如果一定要影响main中a、b变量的值，只能使用return返回，不过，可惜的是，return只能返回一个变量值（返回结构体或自定义类另说）。

3.2 引用传递（传引用）

代码2：

#include<iostream>
using namespace std;
 
//引用传递  交换前a=1,b=2;交换后a=2,b=1;
void swapByReference(int &a,int &b)
{
    cout<<"swapByReference函数  交换前"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    int temp=a;
    a=b;
    b=temp;
    cout<<"swapByReference函数  交换后"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
}
//主函数
int main()
{
    int a=1;
    int b=2;
    cout<<"main函数  交换前"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    swapByReference(a,b);//引用传递
    cout<<"main函数  交换后"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    return 0;
}

输出2：

小结2：main函数将a、b变量的引用（别名）传递给swapByReference函数，则swapByReference函数中a、b变量仅仅是main函数中a、b变量的引用（别名），不是一个新的真是存在的变量，所以swapByReference函数中的a变量的地址也是0x6afeec，和main函数中a变量的地址一样，swapByReference函数中的b变量的地址也是0x6afee8，和main函数中b变量的地址一样。

swapByReference函数中，交换了两个内存地址上的内容，因为swapByReference函数中的a、b变量作用域今夏与swapByReference函数，所以随着swapByReference执行完毕，其中的a、b变量也没什么用了。

再次回到main函数，main函数的a、b变量存放于0x6afeec地址和0x6afee8地址中，然后将它们输出交换结果即可。

3.3 指针传递、地址传递（传地址（传址））

因为指针变量的内容就是十六进制的内存地址，所以指针传递就是地址传递，又称为传地址。

代码3：

#include<iostream>
using namespace std;
 
//指针传递  交换前a=1,b=2;交换后a=2,b=1;
void swapByAddress(int *a,int *b)
{
    cout<<"swapByAddress函数  交换前"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  *a="<<*a;
    cout<<"  *b="<<*b<<endl;
    int temp=*a;    //注意：a是地址  *a是内容   b是地址  *b是内容  这里是内容交换，所以是*a和*b交换   这种写法正确
    *a=*b;
    *b=temp;
    cout<<"swapByAddress函数  交换后"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  *a="<<*a;
    cout<<"  *b="<<*b<<endl;
 
    // int temp=a;    //注意：a是地址  *a是内容   b是地址  *b是内容  这里是内容交换，所以是*a和*b交换
    // a=b;               //这种写法正确   这样交换的是地址
    // b=temp;
}
 
//主函数
int main()
{
    int a=1;
    int b=2;
    cout<<"main函数  交换前"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    swapByAddress(&a,&b);//指针传递
    cout<<"main函数  交换后"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    return 0;
}

输出3：

小结3：和上面引用传递不同，在swapByAddress函数中，参数a、b为int *类型（整型指针类型），所以swapByAddress函数中，a、b表示的是地址，*a *b表示的是内容。

从结果中可以看到，实参为&a,&b将变量地址传递给swapByAddress函数，函数接收到地址，使用*a *b获取地址上的内容，交换地址上的内容，最后在main函数中输出。

指针传递中，记住一种错误示范：

代码：

#include<iostream>
using namespace std;
 
void errorFun(int *a,int *b)   //错误示范
{
    cout<<"swapByAddress函数  交换前"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  *a="<<*a;
    cout<<"  *b="<<*b<<endl;
    int *temp=a;    //注意：a是地址  *a是内容   b是地址  *b是内容  这里是内容交换，所以是*a和*b交换   这种写法正确
    a=b;
    b=temp;
    cout<<"swapByAddress函数  交换后"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  *a="<<*a;
    cout<<"  *b="<<*b<<endl;
 
    // int temp=a;    //注意：a是地址  *a是内容   b是地址  *b是内容  这里是内容交换，所以是*a和*b交换
    // a=b;               //这种写法正确   这样交换的是地址
    // b=temp;
}
 
//主函数
int main()
{
    int a=1;
    int b=2;
    cout<<"main函数  交换前"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    errorFun(&a,&b);//指针传递
    cout<<"main函数  交换后"<<endl;
    cout<<"a="<<a;
    cout<<"  b="<<b;
    cout<<"  &a="<<&a;
    cout<<"  &b="<<&b<<endl;
    return 0;
}

输出：

注意：*这是一种错误的示范，swapByAddress函数中交换的是int a,int * b的十六进制的地址，而不是内存地址中的内容，这种地址交换效果类似于值交换，地址交换的结果是不会影响到调用方main函数的，所以main函数中还是a=1,b=2。

四、引用传递和指针传递的区别

C语言中支持两种参数传递方式——值传递和指针传递，C++中支持三种传递方式——值传递、引用传递和指针传递，对于引用传递，C语言不支持，但是C++支持，所以上面的程序可以编译通过。

值传递和指针传递的区别是明显的，值传递是普通变量传递数值，指针传递是指针变量传递引用。

这里谈论引用传递和指针传递的区别，根本区别：引用传递中形参和实参是同一对象，指针传递中形参和实参指向同一对象。

五、尾声

本节介绍C/C++函数参数传递的三种方式——传值、传引用、传地址，是属于C/C++入门级博客，希望对初学者有用。

天天打码，天天进步！

引用和指针的不同点

引用和指针的不同点
1.引用在初始化是引用一个实体后，就不能引用其他的实体，而指针可以在任何时候指向一个同类型的实体。

2.引用在定义时必须初始化，而指针不需要。

3.在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数。

4.没有null引用，但是有null指针。

5.引用自加即引用的实体增加一，指针自加，即指针向后偏移一个类型的大小

6.引用比指针更加安全。

7.访问实体方式不同，指针需要显式解引用，而引用是编译器自己处理。

8.指针有多级指针，但是引用没有多级引用。
9…引用的底层实现：通过指针实现
在底层，引用就是指针
引用本身是有空间的，空间的大小和指针的大小相同，不回去开所指向的实体的空间。
————————————————
版权声明：本文为CSDN博主「小小怪侠士」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/dsjfhdwasfhgakjs/article/details/114542577

C++笔记——参数传递中的指针传递和引用传递

这篇文章主题过于小白了，但是整理了一下能整明白也是值得的。并且以防后面再弄混吧。

值传递：

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

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

指针传递：

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

引用传递：

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

但是这时存放的是由主调函数放进来的实参变量的地址。

被调函数对形参的任何操作都被处理成间接寻址，即通过栈中存放的地址访问主调函数中的实参变量。正因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

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

#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）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

指针传递的实质：

指针传递参数本质上是值传递的方式，它所传递的是一个地址值。值传递过程中，被调函数的形式参数作为被调函数的局部变量处理，

即在栈中开辟了内存空间以存放由主调函数放进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的

任何操作都是作为局部变量进行，不会影响主调函数的实参变量的值。（这里是在说实参指针本身的地址值不会变）如果理解不了大可跳过这段

指针传递和引用传递一般适用于：

函数内部修改参数并且希望改动影响调用者。对比指针/引用传递可以将改变由形参“传给”实参（实际上就是直接在实参的内存上修改，

不像值传递将实参的值拷贝到另外的内存地址中才修改）。

另外一种用法是：当一个函数实际需要返回多个值，而只能显式返回一个值时，可以将另外需要返回的变量以指针/引用传递

给函数，这样在函数内部修改并且返回后，调用者可以拿到被修改过后的变量，也相当于一个隐式的返回值传递吧。

以下是我觉得关于指针和引用写得很不错的文章，大家可参照看一下，原文出处地址：http://xinklabi.iteye.com/blog/653643

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

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

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

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

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

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

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

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

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

★相同点：

●都是地址的概念；

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

★不同点：

●指针是一个实体，而引用仅是个别名；

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

●引用没有const，指针有const，const的指针不可变；（具体指没有int& const a这种形式，而const int& a是有 的， 前者指引用本身即别名不可以改变，这是当然的，所以不需要这种形式，后者指引用所指的值不可以改变）

●引用不能为空，指针可以为空；

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

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

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

一、引用的概念

引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似，只是用&代替了*。
例如： Point pt1(10,10);
Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义，pt1和pt2表示同一对象。
  
需要特别强调的是引用并不产生对象的副本，仅仅是对象的同义词。因此，当下面的语句执行后：
pt1.offset（2，2）；
pt1和pt2都具有（12，12）的值。
  
引用必须在定义时马上被初始化，因为它必须是某个东西的同义词。你不能先定义一个引用后才
初始化它。例如下面语句是非法的：
Point &pt3；
pt3=pt1；
  
那么既然引用只是某个东西的同义词，它有什么用途呢？
下面讨论引用的两个主要用途：作为函数参数以及从函数中返回左值。 

二、引用参数

1、传递可变参数
传统的c中，函数在调用时参数是通过值来传递的，这就是说函数的参数不具备返回值的能力。
所以在传统的c中，如果需要函数的参数具有返回值的能力，往往是通过指针来实现的。比如，实现
两整数变量值交换的c程序如下：
void swapint(int *a,int *b)
{
int temp;
temp=*a;
a=*b;
*b=temp;
}

使用引用机制后，以上程序的c++版本为：
void swapint(int &a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
}
调用该函数的c++方法为：swapint（x,y); c++自动把x,y的地址作为参数传递给swapint函数。

2、给函数传递大型对象
当大型对象被传递给函数时，使用引用参数可使参数传递效率得到提高，因为引用并不产生对象的
副本，也就是参数传递时，对象无须复制。下面的例子定义了一个有限整数集合的类： 
const maxCard=100; 
Class Set 
{
int elems[maxCard]; // 集和中的元素，maxCard 表示集合中元素个数的最大值。 
int card; // 集合中元素的个数。 
public:
Set () {card=0;} //构造函数
friend Set operator * (Set ,Set ) ; //重载运算符号*，用于计算集合的交集 用对象作为传值参数
// friend Set operator * (Set & ,Set & ) 重载运算符号*，用于计算集合的交集 用对象的引用作为传值参数 
...
}
先考虑集合交集的实现
Set operator *( Set Set1,Set Set2)
{
Set res;
for(int i=0;i<Set1.card;++i)
for(int j=0;j>Set2.card;++j)
if(Set1.elems[i]==Set2.elems[j])
{
res.elems[res.card++]=Set1.elems[i];
break;
}
return res;
}
由于重载运算符不能对指针单独操作，我们必须把运算数声明为 Set 类型而不是 Set * 。
每次使用*做交集运算时，整个集合都被复制，这样效率很低。我们可以用引用来避免这种情况。
Set operator *( Set &Set1,Set &Set2)
{ Set res;
for(int i=0;i<Set1.card;++i)
for(int j=0;j>Set2.card;++j)
if(Set1.elems[i]==Set2.elems[j])
{
res.elems[res.card++]=Set1.elems[i];
break;
}
return res;
}

三、引用返回值

如果一个函数返回了引用，那么该函数的调用也可以被赋值。这里有一函数，它拥有两个引用参数并返回一个双精度数的引用：
double &max(double &d1,double &d2)
{
return d1>d2?d1:d2;
}
由于max()函数返回一个对双精度数的引用，那么我们就可以用max() 来对其中较大的双精度数加1：
max(x,y)+=1.0;

编辑于 2020-05-08 00:47