改变常量的值===引用===引用和指针区别

改变常量的值-----------------------------------当给常量赋一个常值时上面的解释还行，如果是赋一变量的值呢，比如int a=10;const int b =a;这时似乎就不能用宏替换来解释了，这时常量和变量也差不太多，只是编译器不准你用b这个符号去修改b的数据所在的内存单元,假如这时你知道b的内存地址那就可以通过指针去修改常量的值了，假如b和a紧邻且在b的地址比a的地址小那么就可以通过下面的方式来修改b的值:int *p=&a;p-=1;*p=11;由此可见如果指针指错了地方，指到常量的地址了，它会把常量也给修改了。“const int a=3;”的意思是不能够通过a修改a所在的这块内存的内容，但是“int *p=(int *)&a;”以后，可以用p来修改，因为并没有对p做限制 int const *pconst=&a; int *pmutable=&a;虽然都是一个地方的数据，通过pmutable就可以修改值，通过pconst是不能修改值的。

引用

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

引用(reference)就是对象的另一个名字.

在实际程序中,引用主要用作函数的形式参数.

引用是一种复合类型(compound type),通过在变量名前添加"&"符号来定义.复合类型是指用其他类型定义的类型.

在引用的情况下,每一种引用类型都"关联到"某一其他类型.不能定义引用类型的引用,但可以定义任何其它类型的引用.

引用必须用与该引用同类型的对象初始化:

int ival=1024;
int &refVal=ival;   //ok: refVal refers to ival
int &refVal2;       //error:a reference must be initialized
int &refVal3=10;    //error:initializer must be an object

1.引用是别名

因为引用只是它绑定的对象的另一个名字,作用在引用上的所有操作事实上都是作用在该引用绑定的对象上:

refVal+=2;     将refVal指向的对象ival加2.类似地,

int ii=refVal    把和ival相关联的值赋给ii. 

注解:当引用初始化后,只要该引用存在,它就保持绑定到初始化时指向的对象.不可能将引用绑定到另一个对象.

现在有点明白了,类似影武者,替身,不过,引用才是真身,被引用绑定的对象叫影武者.  - -   好事坏事都自己顶了

要理解的一个重要概念就是,引用只是对象的另一名字.事实上,我们可以通过ival的原名访问ival,也可以通过它的别名refVal访问.赋值只是另外一种操作.我们可以编写

refVal=5;    效果是把ival的值改为5. 这一规则的结果是必须在定义引用时进行初始化.初始化是指明引用指向哪个对象的唯一方法.唯一唯一唯一唯一唯一唯一唯一唯一唯一唯一唯一唯一!!!!!!!!!!!!!!!!!!!!!!!!!!

2.定义多个引用

可以在一个类型定义行中定义多个引用.必须在每个引用标识符前添加"&"符号;

int i =1024,i2=2048;
int &r=i,r2=i2;   //r is a reference,r2 is an it
int i3=1024,&ri=i3; //defines one object, and one reference
int &r3=i3,&r4=i2;  //defines two reference    这里定义了两个引用,都要在前面加&

3.const引用

const引用是指向const对象的引用:

const int ival=1024;

const int &refVal=ival;   //ok:both reference and object are const

int &ref2=ival;    //error: nonconst reference to a const object  用ival初始化ref2也是不合法的:ref2是普通的非const引用(nonconst reference)

可以读取但不能修改refVal,因此,任何对refVal的赋值都是不合法的.这个限制有其意义:不能直接对ival赋值,因此也不能通过使用refVal来修改ival.

同理,用ival初始化ref2也是不合法的:ref2是普通的非const引用(nonconst reference),因此可以用来修改ref2指向的对象的值.通过ref2对ival赋值会导致修改const对象的之.为阻止这样的修改,需要规定将普通的引用绑定到const对象是不合法的.

术语:const引用是指向const的引用

C++程序员常常随意地使用术语const引用.严格来说,"const引用"的意思是"指向const对象的引用".类似地,程序员使用术语"非const引用"表示指向非const类型的引用.这种用法非常普遍.我们也遵循这种用法.

const引用可以初始化为不同类型的对象或者初始化为右值.如字面值常量:

int i=42;
// legal for const references only
const int &r=42;
const int &r2=r+i;

同样的初始化对于非const引用却是不合法的,而且会导致编译时错误.其原因非常微妙,值得解释一下.

观察将引用绑定到不同的类型时所发生的事情,最容易理解上述行为.假如我们编写

double dval-3.14;   //create temporary int from the double

const int &ri-temp; // bind ri to that temporary

编译器会把这些代码转换成如下形式的编码:

int temp=dval;   //create temporary int from the double

const int &ri=temp;    //bind ri to that temporary

这里的意思是temp是用来进行隐式类型转换的代替变量么?为什么会转换代码?

如果ri不是const,那么可以给ri赋一新值.这样做不会修改dval,而是修改了temp.期望对ri的赋值会修改dval的程序员会发现,dval并没有被修改.仅允许const引用绑定到需要临时使用的值完全避免了这个问题,因为const引用是只读的.(这里不太懂..............................................................)

注解:非const引用只能绑定到与该引用同类型的对象.const引用则可以绑定到不同但相关的类型的对象或绑定到右值.

习题1:哪些定义是非法的?为什么?如何修改

(a)int ival=1.01;
(b)int &rval1=1.01;
(c)int &rval2=ival;
(d)const int &rval3=1;

b.rval1是一个非const引用,不能绑定到右值,而1.01是一个右值.可以改为  int &rval1=ival;

习题2:在上题给出的定义下,下列哪些赋值是非法的.如果赋值合法,解释赋值的作用

(a)rval2=3.14159;
(b)rval2=rval3;
(c)ival=rval3;
(d)rval3=ival;

a.合法赋值.将一个double型字面值赋给int类型ival,发生隐式类型转换.ival的值为3;

b.合法.将int值1赋给变量ival2.

c.合法.将int值1赋给变量ival.

d.非法.rval3是一个const引用,不能进行赋值.

习题3. a中的定义和b中的赋值存在哪些不同?哪些是非法的?

(a)int ival=0;
const int &ri=0;
(b)ival=ri;
ri=ival;

第一行,定义int变量ival并将其初始化为0.

第二行,定义ri为const引用,并将其绑定到右值0

第三行.将0赋给ival

第四行.试图将0赋给const引用ri,非法.ri是const引用,不能赋值.

习题4.下列代码输出什么?

int i,&ri=i;
i=5;ri=10;
cout<<i<<" "<<ri<<endl;

答案:10 10

引用和指针区别

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

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

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

  

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

  

2、指针和引用的区别

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

  

  而声明指针是可以不指向任何对象，也正是因为这个原因，使用指针之前必须做判空操作，而引用就不必。

• 其次，引用不可以改变指向，对一个对象"至死不渝"；但是指针可以改变指向，而指向其它对象。说明：虽然引用不可以改变指向，但是可以改变初始化对象的内容。例如就++操作而言，对引用的操作直接反应到所指向的对象，而不是改变指向；而对指针的操作，会使指针指向下一个对象，而不是改变所指对象的内容。见下面的代码：

  #include<iostream>

  using namespace std;

   

  int main(int argc,char** argv)

  {

      int i=10;

      int& ref=i;

      ref++;

      cout<<"i="<<i<<endl;

      cout<<"ref="<<ref<<endl;

      int j=20;

      ref=j;

      ref++;

      cout<<"i="<<i<<endl;

      cout<<"ref="<<ref<<endl;

      cout<<"j="<<j<<endl;

      return 0;

  }

  对ref的++操作是直接反应到所指变量之上，对引用变量ref重新赋值"ref=j"，并不会改变ref的指向，它仍然指向的是i，而不是j。理所当然，这时对ref进行++操作不会影响到j。而这些换做是指针的话，情况大不相同，请自行实验。输出结果如下：

  

• 再次，引用的大小是所指向的变量的大小，因为引用只是一个别名而已；指针是指针本身的大小，4个字节。见下图所示：

  

  从上面也可以看出：引用比指针使用起来形式上更漂亮，使用引用指向的内容时可以之间用引用变量名，而不像指针一样要使用*；定义引用的时候也不用像指针一样使用&取址。

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

总而言之，言而总之——它们的这些差别都可以归结为"指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名，引用不改变指向。"

3、特别之处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；

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

4、指针和引用的实现

我们利用下面一段简单的代码来深入分析指针和引用:

#include<iostream>

using namespace std;

 

int main(int argc, char** argv)

{

int i=1;

int& ref=i;

int x=ref;

cout<<"x is "<<x<<endl;

 

ref=2;

int* p=&i;

cout<<"ref = "<<ref<<", i = "<<i<<endl;

}

上面的代码用g++ test.c编译之后，然后反汇编objdump -d a.out，得到main函数的一段汇编代码如下：

08048714 <main>: 8048714: 55　　　　push %ebp 8048715: 89 e5　　　mov %esp,%ebp 8048717: 83 e4 f0        and $0xfffffff0,%esp//为main函数的参数argc、argv保留位置 804871a: 56            push %esi 804871b: 53            push %ebx 804871c: 83 ec 28        sub $0x28,%esp 804871f: c7 44 24 1c 01 00 00 movl $0x1,0x1c(%esp) //将0x1存到esp寄存器中，即int i=1 8048726: 00 8048727: 8d 44 24 1c  lea 0x1c(%esp),%eax// esp寄存器里的变量i的地址传给eax 804872b: 89 44 24 18    mov %eax,0x18(%esp)//将寄存器eax中的内容（i的地址）传给寄存器中的变量ref，即int& ref=i 804872f: 8b 44 24 18        mov 0x18(%esp),%eax//将寄存器esp中的ref传给eax，即i的地址 8048733: 8b 00        mov (%eax),%eax//以寄存器eax中的值作为地址，取出值给eax 8048735: 89 44 24 14        mov %eax,0x14(%esp) //将寄存器eax中的值传给寄存器esp中的x，即x=ref 8048739: c7 44 24 04 00 89 04     movl $0x8048900,0x4(%esp) 8048740: 08 8048741: c7 04 24 40 a0 04 08    movl $0x804a040,(%esp) 8048748: e8 cb fe ff ff    call 8048618 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> 804874d: 8b 54 24 14    mov 0x14(%esp),%edx 8048751: 89 54 24 04        mov %edx,0x4(%esp) 8048755: 89 04 24        mov %eax,(%esp) 8048758: e8 5b fe ff ff    call 80485b8 <_ZNSolsEi@plt> 804875d: c7 44 24 04 38 86 04    movl $0x8048638,0x4(%esp) 8048764: 08 8048765: 89 04 24        mov %eax,(%esp) 8048768: e8 bb fe ff ff    call 8048628 <_ZNSolsEPFRSoS_E@plt>//从8048739~8048768这些行就是执行"cout<<"x is "<<x<<endl;" 804876d: 8b 44 24 18    mov 0x18(%esp),%eax//将寄存器esp中的ref传到eax中 8048771: c7 00 02 00 00 00    movl $0x2,(%eax) //将0x2存到eax寄存器中 8048777: 8d 44 24 1c        lea 0x1c(%esp),%eax// esp寄存器里的变量i的地址传给eax 804877b: 89 44 24 10    mov %eax,0x10(%esp) //将寄存器eax中的内容（即i的地址）传到寄存器esp中的p 804877f: 8b 5c 24 1c        mov 0x1c(%esp),%ebx 8048783: 8b 44 24 18    mov 0x18(%esp),%eax 8048787: 8b 30        mov (%eax),%esi 8048789: c7 44 24 04 06 89 04    movl $0x8048906,0x4(%esp) 8048790: 08 8048791: c7 04 24 40 a0 04 08    movl $0x804a040,(%esp) 8048798: e8 7b fe ff ff    call 8048618 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> 804879d: 89 74 24 04    mov %esi,0x4(%esp) 80487a1: 89 04 24        mov %eax,(%esp) 80487a4: e8 0f fe ff ff    call 80485b8 <_ZNSolsEi@plt> 80487a9: c7 44 24 04 0d 89 04    movl $0x804890d,0x4(%esp) 80487b0: 08 80487b1: 89 04 24        mov %eax,(%esp) 80487b4: e8 5f fe ff ff     call 8048618 <_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc@plt> 80487b9: 89 5c 24 04        mov %ebx,0x4(%esp) 80487bd: 89 04 24        mov %eax,(%esp) 80487c0: e8 f3 fd ff ff    call 80485b8 <_ZNSolsEi@plt> 80487c5: c7 44 24 04 38 86 04    movl $0x8048638,0x4(%esp)