精华内容
下载资源
问答
  • C++ 引用和指针区别 常量指针和指针常量的区别
    千次阅读
    2016-09-02 10:11:05
           指针指向一块内存,它的内容是所指内存的地址;
           引用是某块内存的别名

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

    *和const谁在前,就先念谁
    故const int *p叫做常量指针(也可以写作int const *p)
    因为(*p)变成常量,故不能执行*p=x的操作,但是可以修改p指向的地址

    int *const p叫做指针常量
    因为(p)变成常量,故p指向的地址不能修改,但是可以执行*p=x的操作

    const int *const p叫做指向常量的常量指针
    即(p)和(*p)都不能复制

    	int i,j,a,b,c;
    	a=10;
    	b=20;
    	c=30;
    	const int *p=&c; //常量指针
    	p=&a;  //可以修改指针指向
    	*p=2;(Error)  //但是不可以通过*p修改a中的值
    
    	int *const pp=&c;  //指针常量
    	*pp=2;  //可以通过*pp修改c的值
    	pp=&a;   (Error)   //但是指针指向的对象不可更改
    
    	const int *const ppp=&c;
    	*ppp=5;(Error)
    	ppp=&a;(Error)


    更多相关内容
  • int n; int &m = n; 在C++中,多了一个C语言没有的引用声明符&,如上,m就是n的引用,简单的说m就是n的...假如在一个函数中动态申请内存空间,用指针和引用作形参会得到不同的结果,如下面的例子:   void fun(int
  • C++引用和指针区别

    千次阅读 多人点赞 2020-07-10 14:51:40
    引用C++引入的重要机制(C语言没有引用),它使原来在C中必须用指针来实现的功能有了另一种实现的选择,在书写形式上更为简洁。那么引用的本质是什么,它与指针又有什么关系呢? 1.引用的底层实现方式 引用被...

    作者:RainMan
    链接:https://www.zhihu.com/question/37608201/answer/545635054
    来源:知乎
    著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
     

    引用是C++引入的重要机制(C语言没有引用),它使原来在C中必须用指针来实现的功能有了另一种实现的选择,在书写形式上更为简洁。那么引用的本质是什么,它与指针又有什么关系呢?

    1.引用的底层实现方式

    引用被称为变量的别名,它不能脱离被引用对象独立存在,这是在高级语言层面的概念和理解,并未解释引用的实现方式。常见错误说法是“引用”自身不是一个变量,甚至编译器可以不以引用分配空间。

    实际上,引用本身是一个变量,只不过这个变量的定义和使用与普通变量有显著的不同。为了解引用变量底层实现机制,考查如下代码:

    int i=5;
    int &ri=i;
    ri=8;

    在Visual Studio 2017环境的debug模式调试代码,反汇编查看源码对应的汇编代码的步骤是:调试->窗口->反汇编,即可得到如下原码对应的汇编代码:

    int i=5;
    00A013DE  mov        dword ptr [i],5    	//将文字常量5送入变量i
    int &ri=i;
    00A013E5  lea        eax,[i]  	 	    	//将变量i的地址送入寄存器eax
    00A013E8  mov        dword ptr [ri],eax  	//将寄存器的内容(也就是变量i的地址)送入变量ri
    ri=8;
    00A013EB  mov        eax,dword ptr [ri]  	//将变量ri的值送入寄存器eax
    00A013EE  mov        dword ptr [eax],8   	//将数值8送入以eax的内容为地址的单元中
    return 0;
    00A013F4  xor        eax,eax
    

    考查以上代码,在汇编代码中,ri的数据类型为dword,也就是说,ri要在内存中占据4个字节的位置。所以,ri的确是一个变量,它存放的是被引用对象的地址。由于通常情况下,地址是由指针变量存放的,那么,指针变量和引用变量有什么区别呢?使用指针常量实现上面的代码功能。考查如下代码:

    int i=5;
    int* const pi=&i;
    *pi=8;

    按照相同的方式,在VS2017中得都如下汇编代码:

    int i=5;
    011F13DE  mov         dword ptr [i],5  
    int * const pi=&i;
    011F13E5  lea         eax,[i]  
    011F13E8  mov         dword ptr [pi],eax  
    *pi=8;
    011F13EB  mov         eax,dword ptr [pi]  
    011F13EE  mov         dword ptr [eax],8  
    

    观察以上代码可以看出:

    (1)除了pi与ri变量名不同,所得汇编代码与第一段所对应的汇编代码完全一样。所以,引用变量在功能上等于一个指针常量,即一旦指向某一个单元就不能在指向别处。

    (2)在底层,引用变量由指针按照指针常量的方式实现。

    2.高级语言层面引用与指针常量的关系

    1.引用和指针,在内存中都是占用4个字节(32bits系统中)的存储空间。指针和引用存放的都是被引用对象的地址,都必须在定义的同时进行初始化。

    2.指针常量本身(以p为例)允许寻址,即&p返回指针常量(常变量)本身的地址,被引用对象用*p表示;引用变量本身(以r为例)不允许寻址,&r返回的是被引用对象的地址,而不是变量r的地址(r的地址由编译器掌握,程序员无法直接对它进行存取),被引用对象直接用r表示。

    3.凡是使用了引用变量的代码,都可以转换成使用指针常量的对应形式的代码,只不过书写形式上要繁琐一些。反过来,由于对引用变量使用方式上的限制,使用指针常量能够实现的功能,却不一定能够用引用来实现。

    例如,下面的代码是合法的:

    int i=5,j=6;
    int* const array[]={&i,&j};

    而如下代码是非法的:

    int i=5,j=6;
    int& array[]={i,j};

    也就是说,数组元素允许是指针常量,却不允许是引用。C++语言机制如此规定,原因是避免C++语法变得过于晦涩。假如定义一个“引用的数组”,那么array[0]=8;这条语句该如何理解?是将数组元素array[0]本身的值变成8呢,还是将array[0]所引用的对象的值变成8呢?对于程序员来说,这种解释上的二义性对正确编程是一种严重的威胁,毕竟程序员在编写程序的时候,不可能每次使用数组时都要回过头去检查数组的原始定义。

    即得出两个不同:引用只能在定义时被初始化一次,之后不可变,但是指针可变;引用没有 const,指针有 const。

    4.一些其他不同:

    引用使用时无需解引用(*),指针需要解引用;

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

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

    指针和引用的自增(++)运算意义不一样;引用自增被引用对象的值,指针自增内存地址。

     

    https://blog.csdn.net/tianguiyuyu/article/details/102941951

    c++中引用的本质

    c++中引用就是一个常指针,其也占用内存空间。

    1)引用在C++中的内部实现是一个常指针

    Type& name 《-》Type* const name

    2)C++编译器在编译过程中使用常指针作为引用的内部实现,因此引用所占用的空间大小与指针相同。

    3)从使用的角度,引用会让人误会其只是一个别名,没有自己的存储空间。这是C++为了实用性而做出的细节隐藏

    具体点:如下:

    1)引用在实现上,只不过是把:间接赋值成立的三个条件的后两步和二为一

    (简介赋值的三个条件: 1定义两个变量 (一个实参一个形参) 2建立关联 实参取地址传给形参  3 *p形参去间接的修改实参的值)

    //当实参传给形参引用的时候,只不过是c++编译器帮我们程序员手工取了一个实参地址,传给了形参引用(常量指针)

    如下图所示,c++编译器会把左边的代码翻译成右边的。

    2)当我们使用引用语法的时,我们不去关心编译器引用是怎么做的

        当我们分析奇怪的语法现象的时,我们才去考虑c++编译器是怎么做的。

    详细点就是看下面的代码:

    
        #include <iostream>
    
        using namespace std;
    
        //1 第一点 单独定义的引用时,必须初始化;说明很像一个常量
    
        void main1()
    
        {
    
        //
    
        const int c1 = 10;
    
        int a = 10;
    
        int& b = a; //b很想一个常量
    
        printf("&a:%d \n", &a);
    
        printf("&b:%d \n", &b); //===> a 和 b就是同一块内存空间的门牌号,a和b的地址是一样的,说明引用b就是a的别名
    
        cout << "hello..." << endl;
    
        system("pause");
    
        return;
    
        }
    
        //2 普通引用有自己的空间吗? 有
    
        struct Teacher
    
        {
    
        char name[64]; //64
    
        int age; //4
    
        int& a; //4 0 //很像指针 所占的内存空间大小
    
        int& b; //4 0
    
        };
    
        //3 引用的本质
    
        void modifyA(int& a1)
    
        {
    
        a1 = 100;
    
        }
    
        void modifyA2(int* const a1)
    
        {
    
        *a1 = 200; //*实参的地址 ,去间接的修改实参的值
    
        }
    
        void main()
    
        {
    
        int a = 10;
    
        //1
    
        modifyA(a); //指向这个函数调用的时候,我们程序员不需要取a的地址
    
        printf("a:%d \n", a); //输出100
    
        //
    
        a = 10;
    
        modifyA2(&a); //如果是指针 需要我们程序员手工的取实参的地址
    
        printf("a:%d \n", a); //输出200
    
        printf("sizeof(Teacher):%d \n", sizeof(Teacher)); //输出76,说明普通引用有自己的内存空间
    
        system("pause");
    
        }
    
        void modifyA3(int* p)
    
        {
    
        *p = 200; //*p 3*p形参去间接修改实参的值
    
        }
    
        //间接赋值
    
        void main11()
    
        {
    
        int a = 10;
    
        int* p = NULL; //间接赋值成立的三个条件 1 定义两个变量
    
        p = &a;
    
        *p = 100;
    
        {
    
        *p = 200;
    
        }
    
        modifyA3(&a); //2 建立关联
    
        }
    
    
        // 123 写在一块
    
        // 12 3
    
        //1 23

     

    展开全文
  • C++中的引用和指针 ★ 相同点: 1. 都是地址的概念;指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名(java中的引用其实也是别名的意思)。 ★ 区别: 1. 指针是一个实体,而引用仅是个别名;2. ...
  • C++指针引用区别

    2012-03-11 09:42:29
    详细分析了指针引用区别,适合初学者了解
  • 主要介绍了C++引用传递与指针传递的区别(面试常见),需要的朋友可以参考下
  • C/C++ 数组和指针引用区别 1.数组和指针区别 (1)定义 数组是一个符号,不是变量,因而没有自己对应的存储空间。但是,指针是一个变量,里面存储的内容是另外一个变量的地址,因为是变量所以指针有自己的...
  • 一、指针和引用区别: 1.指针是一个变量,只不过这个变量存储的是一个地址,指向内存的一个存储单元;引用和原来的变量实质上是同一个东西,只不过是原变量的一个别名。 2.指针的值在初始化后可变,即指向其它的...

    一、指针和引用的区别:

    1.指针是一个变量,只不过这个变量存储的是一个地址,指向内存的一个存储单元;引用和原来的变量实质上是同一个东西,只不过是原变量的一个别名

    2.指针的值在初始化后可变,即指向其它的存储单元;引用只能在定义时被初始化一次,之后不可变

    3.指针有const,常指针不可变;引用没有const(具体指没有 int& const a这种形式,而有const int& a;前者是指引用本身不可改变,后者是指引用所指的值不可以改变)

    4.指针的值可以为NULL;引用的值不能为NULL,并且引用在定义的时候必须进行初始化

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

    6.指针和引用的自加(++)运算意义不一样

    指针自加,比如 int a[2] = {0,10} ;int *pa =a;pa++表示指针往后移动一个int的长度。指向下一个内存地址。即pa从指向由a[0]变成指向a[1]
    引用是值++;比如b是引用a[0]的,++表示a[0]的值++从0变为1;

    7.指针不是类型安全的;而引用是类型安全的(引用比指针多了类型检查)

    8.指针可以有多级;引用只能是一级(即int **p是合法的;而int && a是非法的)


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

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

           引用参数传递过程中,被调函数的形式参数作为局部变量在栈中开辟了内存空间,但这时存放的是由主调函数放进的实参变量的地址。被调用函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数的实参变量。如果想通过指针参数传递来改变主调函数中的相关变量,那就得使用指向指针的指针或指针引用。

    案例分析:

    1.指针参数传递

    //指针函数传递
    #include<iostream>
    using namespace std;
    
    void fun(int *p)
    {
    	cout<<&p<<endl;//0x6ffdf0
    	cout<<p<<endl;//0x6ffe1c
    	cout<<*p<<endl;//16
    	*p=0Xff;
    }
    
    int main()
    {
    	int a=0x10;
    	cout<<&a<<endl;//0X6ffe1c
    	cout<<a<<endl;//16
    	fun(&a);
    	cout<<a<<endl;//255
     } 

    通过指针传递的案例我们可以看到,调用fun(&a)是将a的地址0x6ffe1c传递给p,则*p就指向了a的内容,改变*p后,a的内容自然就改变了,示意图如下:

    2.引用参数传递

    //引用参数传递
    #include<iostream>
    using namespace std;
    
    void fun2(int &p)
    {
    	cout<<&p<<endl;//0x6ffe1c
    	cout<<p<<endl;//16
    	p=0Xff;
    }
    int main()
    {
    	int a=0x10;
    	cout<<&a<<endl;//0x6ffe1c
    	cout<<a<<endl;//16
    	fun2(a);
    	cout<<a<<endl;//255
     } 

    通过上面引用传递传递案例我们可以看到,调用fun2(a)时,传递给p的是a的地址,所以p和a的地址都是0x6ffe1c,所以p就是a,改变p当然能改变a。示意图如下:

    3.值传递

    //值传递
    #include<iostream>
    using namespace std;
    
    void fun3(int p)
    {
    	cout<<&p<<endl;//0x6ffdf0
    	cout<<p<<endl;//16
    	p=0Xff;
    }
    
    int main()
    {
    	int a=0x10;
    	cout<<&a<<endl;//0x6ffe1c
    	cout<<a<<endl;//16
    	fun3(a);
    	cout<<a<<endl;//16
     } 

     通过上例我们可以看到,int a=0x10,存放的地址为0x6ffe1c,值为16,当调用fun3(a)时,传递给p的值为16,但是p的地址为0x6ffdf0,当改变p=0xff时是改变地址为0x6ffdf0中的内容,并没有改变0x6ffe1c中的内容,所以调用f(a),后a的值仍然为0x10,所以值传递无法改变变量的值。示意图如下:

    展开全文
  • C/C++引用和指针区别

    万次阅读 多人点赞 2019-05-28 21:57:58
    为什么C/C++语言使用指针?...C++指针暴露给了用户(程序员),而JavaC#等语言则将指针隐藏起来了。 “Everything uses pointers. C++ just exposes them rather than hiding them,” It's easier to gi...

    为什么C/C++语言使用指针?

    答案:①一方面,每一种编程语言都使用指针。不止C/C++使用指针。

    每一种编程语言都使用指针。C++将指针暴露给了用户(程序员),而Java和C#等语言则将指针隐藏起来了。

    “Everything uses pointers. C++ just exposes them rather than hiding them,”

    It's easier to give someone an address to your home than to give a copy of your home to everyone.

    ②另一方面

    使用指针的优点和必要性:

    • 指针能够有效的表示数据结构;
    • 能动态分配内存,实现内存的自由管理;
    • 能较方便的使用字符串;
    • 便捷高效地使用数组
    • 指针直接与数据的储存地址有关,比如:值传递不如地址传递高效,因为值传递先从实参的地址中取出值,再赋值给形参代入函数计算;而指针则把形参的地址直接指向实参地址,使用时直接取出数据,效率提高,特别在频繁赋值等情况下(注意:形参的改变会影响实参的值!)

    引用和指针有什么区别?

    本质:引用是别名,指针是地址,具体的:

    ①从现象上看,指针在运行时可以改变其所指向的值,而引用一旦和某个对象绑定后就不再改变。这句话可以理解为:指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象,以后不能改变,但是指定的对象其内容可以改变。
    从内存分配上看,程序为指针变量分配内存区域,而不为引用分配内存区域,因为引用声明时必须初始化,从而指向一个已经存在的对象。引用不能指向空值。
    注:标准没有规定引用要不要占用内存,也没有规定引用具体要怎么实现,具体随编译器 http://bbs.csdn.net/topics/320095541
    ③ 从编译上看,程序在编译时分别将指针和引用添加到 符号表上,符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值,而 引用在符号表上对应的地址值为 引用对象的地址值。符号表生成后就不会再改,因此指针可以改变指向的对象(指针变量中的值可以改),而引用对象不能改。这是使用指针不安全而使用引用安全的主要原因。从某种意义上来说 引用可以被认为是不能改变的指针
    ④不存在指向空值的引用这个事实,意味着使用引用的代码效率比使用指针的要高。因为在使用引用之前不需要测试它的合法性。相反,指针则应该总是被测试,防止其为空。
    ⑤理论上,对于指针的级数没有限制,但是引用只能是一级。如下:
      int** p1;         // 合法。指向指针的指针
      int*& p2;         // 合法。指向指针的引用
      int&* p3;         // 非法。指向引用的指针是非法的
      int&& p4;         // 非法。指向引用的引用是非法的
      注意上述读法是 从左到右。 

     

    来源: <http://www.tc5u.com/cpp/2400451.htm>

     

     

    下面用通俗易懂的话来概述一下:

    • 指针-对于一个类型T,T*就是指向T的指针类型,也即一个T*类型的变量能够保存一个T对象的地址,而类型T是可以加一些限定词的,如const、volatile等等。见下图,所示指针的含义:

    • 引用-引用是一个对象的别名,主要用于函数参数和返回值类型,符号X&表示X类型的引用。见下图,所示引用的含义:

    首先,引用不可以为空,但指针可以为空。前面也说过了引用是对象的别名,引用为空——对象都不存在,怎么可能有别名!故定义一个引用的时候,必须初始化,不初始化的话连编译都通不过(编译时错误)。因此如果你有一个变量是用于指向另一个对象,但是它可能为空,这时你应该使用指针;如果变量总是指向一个对象,i.e.,你的设计不允许变量为空,这时你应该使用引用。

    注意:正因为指针可以不指向任何对象,使用指针之前必须做判空操作,而引用就不必

     

    其次,引用不可以改变指向,对一个对象"至死不渝";但是指针可以改变指向,而指向其它对象。说明:虽然引用不可以改变指向,但是可以改变初始化对象的内容。

    例如就++操作而言,对引用的操作直接反应到所指向的对象,而不是改变指向;而对指针的操作,会使指针指向下一个对象,而不是改变所指对象的内容。

     

    再次,引用的大小是所指向的变量的大小,因为引用只是一个别名而已;指针是指针(地址)本身的大小,32位系统下,一般为4个字节。

     

    最后,引用比指针更安全。由于不存在空引用,并且引用一旦被初始化为指向一个对象,它就不能被改变为另一个对象的引用,因此引用很安全。对于指针来说,它可以随时指向别的对象,并且可以不被初始化,或为NULL,所以不安全。const 指针虽然不能改变指向,但仍然存在空指针,并且有可能产生野指针(即多个指针指向一块内存,free掉一个指针之后,别的指针就成了野指针)。

     

    总之,可以归结为"指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名,引用不改变指向。"

    特别之处const

    为什么要提到const关键字呢?因为const对指针和引用的限定是有差别的:

    常量指针VS常量引用

     

    常量指针:指向常量的指针,在指针定义语句的类型前加const,表示指向的对象是常量。

    定义指向常量的指针只限制指针的间接访问操作,而不能规定指针指向的值本身的操作规定性。

     常量指针定义"const int* pointer=&a"告诉编译器,*pointer是常量,不能将*pointer作为左值进行操作。

     

    常量引用:指向常量的引用,在引用定义语句的类型前加const,表示指向的对象是常量。也跟指针一样不能对引用指向的变量进行重新赋值操作。

     

    指针常量VS引用常量

     

    在指针定义语句的指针名前加const,表示指针本身是常量。在定义指针常量时必须初始化!而这是引用与生俱来的属性,无需使用const。

     

    指针常量定义"int* const pointer=&b"告诉编译器,pointer(地址)是常量,不能作为左值进行操作,但是允许修改间接访问值,即*pointer(地址所指向内存的值)可以修改。

     

    常量指针常量VS常量引用常量

     

    常量指针常量:指向常量的指针常量,可以定义一个指向常量的指针常量,它必须在定义时初始化。

    定义"const int* const pointer=&c"

    告诉编译器,pointer和*pointer都是常量,他们都不能作为左值进行操作。

     

    而不存在所谓的"常量引用常量",因为引用变量就是引用常量。C++不区分变量的const引用和const变量的引用。程序决不能给引用本身重新赋值,使他指向另一个变量,因此引用总是const的。如果对引用应用关键字const,起作用就是使其目标称为const变量。即

    没有:const double const& a=1;

    只有const double& a=1;

    1. double b=1;
    2. constdouble& a=b;
    3. b=2;//正确
    4. a=3;//出错error: assignment of read-only reference `a'

     

     

     

    总结:有一个规则可以很好的区分const是修饰指针,还是修饰指针指向的数据——画一条垂直穿过指针声明的星号(*),如果const出现在线的左边指针指向的数据为常量;如果const出现在右边指针本身为常量。而引用本身就是常量,即不可以改变指向。

     

    指针传递和引用传递

    为了更好的理解指针和引用,下面介绍一下指针传递和引用传递。当指针和引用作为函数的参数是如何传值的呢?

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

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

     

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

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

    std::thread线程需要引用传递参数时,需要std::ref()支持

     

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

    相同点

    ●都是地址的概念;

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

    不同点

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

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

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

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

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

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

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

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

     

    参考文献:http://bbs.csdn.net/topics/80358667

    http://www.guokr.com/post/443914/

    http://blog.csdn.net/listening_music/article/details/6921608

    http://www.tc5u.com/cpp/2400451.htm

    转自:https://www.cnblogs.com/gxcdream/p/4805612.html

    补充:

    1。引用类型成员变量,不必初始化?必须在构造函数的初始化列表中进行初始化,所指定的变量的生存期一定要长于该类的生存期。

    https://blog.csdn.net/lazyq7/article/details/48186291

    https://blog.csdn.net/olivia77livy/article/details/79664232

    https://blog.csdn.net/DirkNow/article/details/8664298

    展开全文
  • 引用的特点: ①一个变量可取多个别名。 ②引用必须初始化。 ③引用只能在初始化的时候引用一次 ,不...(4)引用声明完毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,且不能再把该引用名作为其他...
  • C++指针和引用区别

    千次阅读 2018-08-20 10:13:59
    指针和引用区别 1.引用不可以为空,但指针可以为空。定义一个引用的时候,必须初始化; 2.引用一旦初始化后不可以再改变指向(但可以改变所指向对象的内容),而指针可以改变指向。 3.引用的大小是所指向的变量的...
  • 指针引用C++中很常用,但是对于它们之间的区别很多初学者都不是太熟悉,下面来谈谈他们2者之间的区别和用法。 1.指针引用的定义和性质区别: (1)指针指针是一个变量,只不过这个变量存储的是一个地址,指向...
  • c++ 引用传参和指针传参的区别

    千次阅读 2019-05-26 19:32:47
    指针从本质上讲是一个变量,变量的值是另一个变量的地址,指针在逻辑上是独立的,它可以被改变的,包括指针变量的值(所指向的地址)和指针变量的值对应的内存中的数据(所指向地址中所存放的数据)。 引用从本质上...
  • c++引用指针区别

    千次阅读 多人点赞 2019-01-31 20:09:02
    c++引用指针区别  ★ 相同点:  1. 都是地址的概念;  指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名。   指针的权威定义: In a declaration T D where D has the form * cv-...
  • c++智能指针介绍 由于 C++ 语言没有自动内存回收机制,程序员每次 new 出来的内存都要手动 delete,比如流程太复杂,最终导致没有 delete,异常导致程序过早退出,没有执行 delete 的情况并不罕见,并造成内存泄露。...
  • 浅谈C++引用和指针区别

    千次阅读 2019-04-15 02:00:13
    之前我们介绍了什么是引用,错过的小伙伴们可以戳这里 ↓ ...既然引用底层是用指针形式实现的,那么这篇文章就来为大家介绍一下引用和指针区别: int main() { int a = 10; int& ra = a; ra = 20; int...
  • C++引用&和指针在作为形参时的区别 int n; int &m = n; 在C++中,多了一个C语言没有的引用声明符&,如上,m就是n的引用,简单的说m就是n的别名,两者在内存中占同样的位置,不对m开辟新的内存空间,对m的任何操作,...
  • 主要介绍了C++中指针和引用区别详解的相关资料,需要的朋友可以参考下
  • C++引用和指针区别

    万次阅读 多人点赞 2011-10-31 15:26:27
    下面用通俗易懂的话来概述一下: 指针-对于一个类型T,T*就是指向T的指针类型,也即一个T*类型的变量能够保存一个T对象的地址,而类型T是可以加一些限定词的,如const、volatile等等。...2、指针和引用区别
  • C++ 指针和引用

    千次阅读 2021-01-17 22:54:20
    C++ 指针和引用C++ 指针和引用1. 指针和引用区别2. 指针3. 引用4. 引用&&指针 作为参数4.1. 常引用5. 把引用&&指针 作为返回值6. 引用&&指针 实现多态 1. 指针和引用区别   很多情况...
  • C++中指针和引用区别(超详细)

    万次阅读 多人点赞 2015-11-10 17:40:31
    指针和引用主要有以下区别引用必须被初始化,但是不分配存储空间。指针不声明时初始化,在初始化的时候需要分配存储空间。 引用初始化后不能被改变,指针可以改变所指的对象。 不存在指向空值的引用,但是...
  • 主要介绍了C++引用指针区别实例详解的相关资料,需要的朋友可以参考下
  • c++引用和c的指针区别和相同点(超详细)

    千次阅读 多人点赞 2020-05-09 11:07:52
    cout运行结果:2 在这里我们可以看到,两个产生的结果是一样的,都是把a的值从1变成了2,第一个代码的方法是通过c的指针来实现这种方法,第二个代码的方法是通过c++引用来实现这种方法(注解:仅c++有这种用法,...
  • C++ 引用以及引用指针区别

    千次阅读 2018-12-09 21:54:58
    前面整理了指针的用法,但是经常和指针拿来对比东西是引用。确实指针在使用的过程中会有很多的麻烦,比如赋初值、使用时判空、无效指针、深浅拷贝等等。在我看来引用指针的高级替代,它的使用规则规避了很多出错的...
  • C++ 引用和指针区别

    千次阅读 2018-08-29 14:15:09
    一个变量的引用可以转为指向它的指针。 不同: 1.初始化不同,引用使用时必须初始化,且只能指向一个变量,初始化不能指向其他变量;指针不一样,指针使用时不必初始化,可以指向nullptr,初始化后仍可以改变指向...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 304,779
精华内容 121,911
关键字:

c++引用和指针的区别

c++ 订阅