精华内容
下载资源
问答
  • 引用取地址符的区别
    千次阅读
    2020-03-27 09:35:10

    一个是用来传值的 一个是用来获取首地址的

    &(引用)==>出现在变量声明语句中位于变量左边时,表示声明的是引用.

    例如: int &rf; // 声明一个int型的引用rf.
    &(取地址运算符)==>在给变量赋初值时出现在等号右边或在执行语句中作为一元运算符出现时
    表示取对象的地址.

    在C++中,既有引用又有取地址,好多人对引用和取地址不是很清楚,因此也无法区分。其实他们的区别可以用一句话概括:**和类型在一起的是引用,和变量在一起的是取址。**下面我们通过实例具体了解一下

    1)引用在赋值=的左边,而取地址在赋值的右边,比如

    int a=3;
    int &b=a; //引用
    int *p=&a; //取地址
    2)和类型在一起的是引用,和变量在一起的是取址。 举例同样如上,还有下例:

    int function(int &i)

    {

    } //引用
    3)对于vector,上面2条同样适合

    vector vec1(10,1); //initialize vec1: 10 elements, every element’s value is 1
    vector &vec2 = vec1; // vec2 is reference to vec1
    vector *vec3 = &vec2; //vec3 is addresss of vec1 and vec2

    更多相关内容
  • 在C++中,既有引用又有取地址,好多人对引用和取地址不是很清楚,因此也无法区分。其实他们的区别可以用一句话概括:类型在一起的是引用变量在一起的是取址。下面我们通过实例具体了解一下 1)
  • 这个符号的意思就是取地址和对位进行与运算 , 但在C++中 , & 被重载多了一种意思 , 就是引用。 在这里我就不介绍位与运算了 , 我先介绍一下取地址运算 ,在学习指针的时候我们就已经用过了取地址符了 , ...

    1.

     在习惯了C语言的程序员眼里 , & 这个符号的意思就是取地址和对位进行与运算 , 但在C++中 , & 被重载多了一种意思 , 就是引用。

     在这里我就不介绍位与运算了 , 我先介绍一下取地址运算  ,在学习指针的时候我们就已经用过了取地址符了 , 使用方法为在变量前面加上&即可。

    接下来是介绍引用 , 简单来说 , 引用就是被引变量的另一个名字 , 当改变引用值时 , 被引值也会改变 , 因为它们两就是同一个值 , 另外 , 引用不能脱离对象单独存在 , 引用是依附与对象存在的 , 因为引用在定义后可能被使用 , 所以引用不能是无对象的 , 所以引用在定义时必须初始化

    因为引用是变量的别名 , 所以不能将某一种类型的引用绑定到另一种类型的对象上 , 比如不能将char & 赋予int型的变量。但同类型间的引用可以切换绑定 。

    接下来讲一下怎么区别引用和取地址 , 可以这样说 , 引用中的&只会出现在定义中 , 在变量类型(类)名后面(与指针相似) , 并且在接下来的代码中 , &符号都不会再出现 , 只需直接使用引用定义的名字即可 , 而取地址符是不用绑定类名的 , 直接在变量(对象)左边写上& 即可(变量可以是指针或引用 , 毕竟它们也算是变量)。

    为什么要有引用 , 在C++这样一种重视效率的语言里 , 必然需要这样一种类型 , 但我们调用一个函数时 , 就必须把参数全部复制一次 , 这样既浪费时间又浪费空间 , 但当我们把函数列表中的形参改为该类型的引用时 , 编译器就不会把整个对象复制进去 , 而只是把对象的地址传过去 , 这样在函数里使用的就是实参本身了 , 也能够修改它的值。

    注意在调用函数的时候直接使用对象名即可 , 不要再加一个& , 那样会变成传地址(参照上文)。

     现在讲一下为什么不能把常量赋给引用 , 这里需要引入左值和右值的概念, 从字面并不能准确的理解左值右值 , 从对象的用途来讲 , 右值用的是对象中的内容而不在乎对象存储的位置(内存中) , 而左值既要内容也必须需要存储位置 , 从语句上讲 , 左值能够位于赋值表达式左边被赋值 , 右值则不然 , 从存在时间来讲 , 左值在作用域内会一直存在 , 右值在使用后就会马上被销毁。 综上来看  ,左值在使用场合上多于右值 , 也能代替右值 , 但右值却不能代替左值 。 定义的内置类型变量 , 对象 , 指针 , 引用等都是左值 , 而常数 , 字符串常量 , 变量间运算后的值(如 i + 5  , 而不是 i = i + 5) , 函数返回的非引用值等都是右值。 这就是为什么 int &ri = 5 是非法的了。因为引用必须绑定到左值。右值引用(&&)暂不讨论。

    2.总结

    1)引用在赋值=的左边,而取地址在赋值的右边,比如
    int a=3;
    int &b=a;        //引用
    int *p=&a;        //取地址

     

    2)和类(或函数定义处)在一起的是引用, 和变量在一起的是取址。 举例同样如上,还有下例:
    int function(int &i)
    {
    }  //和类型在一起的是引用

    注:其实2)与1)是一个道理。

    在函数f()处进行的其实是 int &i =  a, 所以是引用;

    而如下例,进行的其实是 int* i = &a, 所以是取地址。

     

    3)对于vector,上面2条同样适合
    vector<int> vec1(10,1);          //initialize vec1: 10 elements, every element's value is 1
    vector<int> &vec2 = vec1;    // vec2 is  reference to vec1
    vector<int> *vec3 = &vec2;  //vec3 is addresss of vec1 and vec2

     

    举例

     

    指针和引用的区别:

    1.首先,引用不可以为空,但指针可以为空。前面也说过了引用是对象的别名,引用为空——对象都不存在,怎么可能有别名!故定义一个引用的时候,必须初始化。因此如果你有一个变量是用于指向另一个对象,但是它可能为空,这时你应该使用指针;如果变量总是指向一个对象,i.e.,你的设计不允许变量为空,这时你应该使用引用。而声明指针是可以不指向任何对象,也正是因为这个原因,使用指针之前必须做判空操作,而引用就不必

    2.其次,引用不可以改变指向,对一个对象"至死不渝";但是指针可以改变指向,而指向其它对象。说明:虽然引用不可以改变指向,但是可以改变初始化对象的内容。例如就++操作而言,对引用的操作直接反应到所指向的对象,而不是改变指向;而对指针的操作,会使指针指向下一个对象,而不是改变所指对象的内容。

    3.再次,引用的大小是所指向的变量的大小,因为引用只是一个别名而已;指针是指针本身的大小,4个字节

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

    总之,用一句话归纳为就是:指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名,引用不改变指向。

    https://blog.csdn.net/qq_26501341/article/details/58192662

     

    其他:

    1. 不要返回局部变量的引用。如果函数做左值,就必须返回引用

    2.常量引用,不能修改指向也不能修改对象的值

    展开全文
  • 指针和引用区别 对于指针来说,它是一个地址,这个地址是一个数值,那么就意味这个数值可以为0(空指针),也可以为其他,即指针可以不指向任何东西。 而对于引用来说,他是一个外号,外号一定是“某个存在物体”...

    一. 指针和引用的区别

    对于指针来说,它是一个地址,这个地址是一个数值,那么就意味这个数值可以为0(空指针),也可以为其他,即指针可以不指向任何东西。

    而对于引用来说,他是一个外号,外号一定是“某个存在物体”的外号,所以引用不能为空,即不能存在空引用。例如我们给小明起了个外号:明明,那我们说明明的时候,就是说小明。对引用的操作与对变量直接操作完全一样。

    根据以上可知指针和引用的一个重要不同:指针可以为空,引用不能为空。这就意味着我们拿到一个引用的时候,是不需要判断引用是否为空的,而拿到一个指针的时候,我们则需要判断它是否为空。这点经常在判断函数参数是否有效的时候使用。
    例如:

    void fun1(int *point)
    {
         // 为了代码的稳健和安全,我们需要判断指针是否有效,通常做法是判断指针是否为
         // 空,其他的判断就需要根据函数的具体功能来判断了
         if(!point)
         {
            return;
         }
         // 函数实现
    }
    
    void fun2(int &refence)
    {
         // 在这里,我们就不用担心refence是否为空
    }
    


    引用修饰函数参数还可以提高效率,例子如下:

    Class Object
    {// 实现省略,只需要知道我们在这里声明了一个类,在下面我们要将这个类的对象作为
     // 函数参数类型来使用};
    void fun1(Object obj)
    {
         // 此函数声明中,obj是值传递,会产生一个临时对象
    }
    void fun2(Object &obj)
    {
        // 我们不用检查obj是否为空,同时,使用引用传递,可以避免临时对象
    }
    void fun3(Object* obj)
    {
        if(!obj)...
        // 需要检查obj是否为空,同时,可以避免临时对象
    }

    我们根据前面的描述,还可以知道指针可以多次赋值,即在某时刻可以指向地址1,换个时候可以指向地址2,例如:

    int a = 0;
    int b = 1;
    int *point = NULL;
    point = &a;     // 在某个时刻,指针可以指向a
    point = &b;     // 换个时刻,指针可以指向b
    

    而引用则不同,引用只能在初始化的时候就赋好值,之后就不能改变了,用外号的例子来说就是"明明"这个外号在出现的时候就是代指小明,之后“明明”这个外号就绑在小明身上了,它不能过段时间换成小暗的外号。对reference_mingming(不是&reference_mingming)的操作,就是对xiaoming的操作。代码如下:

    int xiaoming = 1;
    int &refence_mingming = xiaoming;
    int xiaoan = 2;
    refence_mingming = xiaoan;           // error,引用不能换了
    

    由以上可以,当我们需要某个是否指向为空的时候,我们就需要使用指针了,还有指向的对象需要变化的时候,我们也需要使用指针。其他地方一般推荐引用。

    更多内容可以参见<more effective C++>第一条:引用和指针的区别。

    二. 取地址符&和引用的关键字的区别:

    作引用的关键字时:

    类型名  &  别名 = var;

    1.定义的时候必须初始化,即& 前面有类名或类型名,&别名后面一定带 “=” (在= 左边);

    2.&后面的别名是新的名字,之前不存在

    3. 引用在使用的时候,只用别名,不再使用&,也就是说对于一个引用,其关键字&只出现一次(在定义的时候)。

    4.C++中“引用”的概念就是要作为对象的别名,尽管其自身也会占用内存(此处不同意匿名用户,引用最终会被编译为指针,因此占用内存),但作为对象别名,它要拥有对象本身所有的功能,因此取地址时,取的是对象的地址而不是自己的地址——C++就是这样设计的,要不然很多事情你都干不了.

    5.对引用的操作与对变量直接操作完全一样,则对引用的取地址操作,等同于对变量的取地址,如下图中所示cout<<&c和cout<<&a是一样的。这个不太好理解(c本身也应该有地址吧,这是C++规定的),“&引用” 和“&取地址符”是一样的。

     

    &取地址时:

    如果&是取址运算符,也就意味着取一个变量的地址并付给指针变量。&后面紧跟的是变量(已存在);

    所以依据&后面的变量名是否已经存在,也很容易判断是引用还是取地址符。

    下面给出一个例子来说明引用和指针的区别,以及引用的地址的问题。

    int a=1;
    int &c=a;
    int *b=&a;
    int main()
    {
    	cout<<c<<endl;  //此时的c就是a,输出1
    	cout<<&c<<endl;  //输出的是c的存储地址也就是a的地址
    	cout<<&a<<endl; //和cout<<&c<<endl;和上一个代码一样
    	cout<<*&c<<endl;  //*直接取这个地址的结果,也就是输出1,也就是a也是c
    	cout<<b<<endl;   //b是指针,指向的是a的地址,输出就是a的地址
    	cout<<*b<<endl;  //指针指向地址里面结果,也就是输出1咯
    	system("pause");
    }
    

     

    展开全文
  • 引用是给已定义的变量起别名。 引用:在声明的时候一定要初始化 #include <iostream> using namespace std; int main() { int a = 88; int &c = a; //声明变量a的一个引用c,c是变量a的一个别名,...

    引用是给已定义的变量起别名

    引用:在声明的时候一定要初始化

    #include <iostream>
     
    using namespace std;
     
    int main()
    {
        int a = 88;
        int &c = a;  //声明变量a的一个引用c,c是变量a的一个别名,如果引用,声明的时候一定要初始化
        int &d = a;  //引用声明的时候一定要初始化,一个变量可以有多个引用
        
        cout<<"a="<<a<<endl;
        cout<<"c="<<c<<endl;
        cout<<"====================="<<endl;
        c=99;
        cout<<"a="<<a<<endl;
     
        return 0;
    }

    &(引用)==>用来传值出现在变量声明语句中位于变量 左边时,表示声明的是引用。

    &(取地址运算符)==>用来获取首地址,在给变量赋初值时出现在等号右边或在执行语句中作为一元运算符出现时,表示取对象的地址.

    总而言之和类型在一起的是引用和变量在一起的是取址

    实例如下:1)引用在赋值=的左边,而取地址在赋值的右边,比如

    int a=3;
    int &b=a;        //引用
    int *p=&a;        //取地址

      2)和类型在一起的是引用,和变量在一起的是取址。 举例同样如上,还有下例:

    int function(int &i)
    {
    }  //引用

    3)对于vector,上面2条同样适合

    vector<int> vec1(10,1);  //initialize vec1: 10 elements, every element's value is 1
    vector<int> &vec2 = vec1; // vec2 is  reference to vec1
    vector<int> *vec3 = &vec2; //vec3 is addresss of vec1 and vec2

    --指针-对于一个类型T,T*就是指向T的指针类型(指针只是指向首地址,即第一个字节,一般情况下,变量或对象占多个字节,而占多少字节是由类型决定的,所有指针定义时要说明类型,也即一个T*类型的变量能够保存一个T对象的地址,而类型T是可以加一些限定词的,如const、volatile等等。见下图,所示指针的含义

    char c = 'a';

    char *p = &c; //p里面存放的是c的地址

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

    int i=1;

    int &r = i;    //此时i=r=1

    若执行r=2;//此时i=r=2

    int *p = &r;  //p指向r;

    指针和引用的区别

    1.首先,引用不可以为空,但指针可以为空。前面也说过了引用是对象的别名,引用为空——对象都不存在,怎么可能有别名!故定义一个引用的时候,必须初始化。因此如果你有一个变量是用于指向另一个对象,但是它可能为空,这时你应该使用指针;如果变量总是指向一个对象,i.e.,你的设计不允许变量为空,这时你应该使用引用。而声明指针是可以不指向任何对象,也正是因为这个原因,使用指针之前必须做判空操作,而引用就不必。

    2.其次,引用不可以改变指向,对一个对象"至死不渝";但是指针可以改变指向,而指向其它对象。说明:虽然引用不可以改变指向,但是可以改变初始化对象的内容。例如就++操作而言,对引用的操作直接反应到所指向的对象,而不是改变指向;而对指针的操作,会使指针指向下一个对象,而不是改变所指对象的内容。

    3.再次,引用的大小是所指向的变量的大小,因为引用只是一个别名而已指针是指针本身的大小,4个字节

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

    总之,用一句话归纳为就是:指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名,引用不改变指向。

    展开全文
  • 引用和取地址区别

    2014-09-06 20:50:00
    一个是用来传值的 一个是用来获取首地址的 &...(取地址运算符)==>在给变量赋初值时出现在等号右边或在执行语句中作为一元运算符出现时 表示取对象的地址. 在C++中,既有引用又有取地...
  • &(引用): 1.用途:给已定义的变量起别名,用来传值。 2.注意事项:在声明的时候一定要初始...(取地址运算符): 1.用途:获取首地址。 2.判断方法: 判断方法一:在给变量赋初值时出现在等号的右边;或者,在执行
  • 最近在学习C++中,看到也有一个&,但是这个是一个叫做引用的新特性...这个是取地址用的,具体区别是啥,我们去找找看: 贴几个链接: C++中 引用&与取地址&的区别 C++中引用(&)的用法应用实例 ...
  • 引用是在写函数定义的时候用,调用的时候直接写,没有取地址符&, 指针是在函数定义的时候用*,调用的时候用取地址符号&,例如: void funcA(int& a,int& b)//这是引用 { //TODO } void funcB...
  • 关于引用取地址&运算符的用法

    千次阅读 2018-08-16 14:18:15
    这个符号的意思就是取地址和对位进行与运算 , 但在C++中 , &amp; 被重载多了一种意思 , 就是引用。   在这里我就不介绍位与运算了 , 我先介绍一下取地址运算 ,在学习指针的时候我们就已经用过了取地址...
  • 引用引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。&作为引用的时候,必须在定义时候就进行初始化,若不进行初始化则会编译报错。 int c; int &ic=c; 即c的身份被ic...
  • C++引用取地址

    2020-03-22 00:04:41
    引用和取地址符都是用符号“&”来表示,很容易分不清。但是,他们有以下的区别。 1.定义时,“=”左边的基本都是引用,“=“右边的是取地址 int x = 0 ; int& a = x ; int* p = &x; 2.引用必须要...
  • 作用上的不同 &作为引用是某一变量(目标)的一个别名...类型在一起的是引用变量在一起的是取址(表现形式为:引用在赋值=的左边,而取地址在赋值的右边) int a=3; int &b=a; //引用 int *p=&a;...
  • 引用 引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。 &作为引用的时候,必须在定义时候就进行初始化,若不进行初始化则会编译报错。...取地址就是你想取某变量(形参或者实
  • 指针、引用取地址

    千次阅读 2017-12-10 21:12:24
    C++中指针、引用取地址的联系与区别
  • 详解地址和引用区别

    千次阅读 2018-02-14 14:24:17
     ★ 区别: 1. 指针是一个实体,而引用仅是个别名; 2. 引用使用时无需解引用(*),指针需要解引用; 3. 引用只能在定义时被初始化一次,之后不可变;指针可变; 引用“从一而终” ^_^ 4. 引用没有 const,...
  • C中引用'&'与取地址'&'的区别

    千次阅读 2014-11-24 10:35:37
    一个是用来传值的 一个是用来获取首地址的 &(引用)==>出现在变量声明语句中位于变量左边时,表示声明的是引用.   例如: int &rf; // 声明一个int型的引用rf. ...在C++中,既有引用又有取地址,好多
  • 废话少说,上例子:1、取地址在等号右边,引用在等号左边 int m = 3; int &n = m; //引用 int *p = &m; //取地址2、类型一起的是引用变量在一起的是取地址 int fuc(int &n); //引用
  • 一站式解决*,&,->,(.),**,取地址,解引用,值传递,地址传递的区别
  • 引用不是新定义一个变量,而是给已存在变量了一个别名,编译器不会为引用变量开辟内存空间,它引用的变量共用同一块内存空间。 说白了,引用就是给变量起外号,比如一个人可以有乳名,有学名,有笔名,其实就...
  • 引用取地址

    千次阅读 2013-08-25 11:00:43
    转载自:http://blog.sina.com.cn/s/blog_4cd5d2bb0100bizc.html ... 引用实际上就是给同一个变量了多个名字。  举个例子:  有个人的名字叫a,之后又改名叫b,这时ab都是指这个人,这样b就引用了a,即b就是
  • ,就是“取地址”的意思。但对于*,翻译为“解引用”,字面意思不好理解,即使看了后面内容才知道不过是“取指针指向的地址的内容”,"*"的作用是引用指针指向的变量值,引用其实就是引用该变量的地址,“解”就是把...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 168,776
精华内容 67,510
关键字:

引用和取地址的区别