(int &)a 和（int）a

 

[cpp] view plain copy

1. float a = 1.0f;  
2.  
3. cout < < (int)a < < endl;  
4.  
5. cout < < (int&)a < < endl;  
6.  
7. cout < < boolalpha < < ( (int)a == (int&)a ) < < endl; // 输出什么？  
8.  
9. float b = 0.0f;  
10.  
11. cout < < (int)b < < endl;  
12.  
13. cout < < (int&)b < < endl;  
14.  
15. cout < < boolalpha < < ( (int)b == (int&)b ) < < endl; // 输出什么？  

输出啥？不明白 (int &)a是啥意识？为啥两个比较的出结果不同。

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

[cpp] view plain copy

1. cout < < boolalpha < < ( (int)a == (int&)a ) < < endl;  

// 输出 false, 因为 float 的 1 和 int 的 1 在内存里的表示不一样。

...

[cpp] view plain copy

1. cout < < boolalpha < < ( (int)b == (int&)b ) < < endl; // 输出 true  

// 输出 true, 因为 float 的 0 和 int 的 0 在内存里的表示是一样的。

(int &)a 就表示 不管 a 是什么，我都当他是一个int变量。

从机器码的角度来说，变量a会被翻译成一个内存地址，(int &)a 就是说，这个内存地址里的内容它是一个整数。

(int)a 呢不同：如果 a 不是整数，就会按规则转换成整数，存入另一个地址(或临时变量)中去。

浮点数的 1.0f 在内存里是这样表示的：

0011 1111 1000 0000 00000000 00000000

这个32位二进制数被当作整数输出就是：

1065353216

而整数的 1 在内存里是这样表示的：

0000 0000 0000 0000 00000000 00000001

所以 (int)a != (int&)a

浮点的0和整数的0 在内存里都是：

0000 0000 0000 0000 00000000 00000000

所以 (int)b == (int&)b

[cpp] view plain copy

1. <span style="font-size:16px;">#include <iostream>  
2.  
3. #include <stdio.h>  
4.  
5. #include <string.h>  
6.  
7. #include <conio.h>  
8.  
9. using namespace std;  
10.  
11.  
12. int main()  
13.  
14. {  
15.  
16. float a = 1.0f;  
17.  
18.  
19. cout << sizeof(int) <<endl;//4  
20.  
21. cout << sizeof(float) <<endl;//4  
22.  
23.  
24. cout << (int)a << endl;//1  
25.  
26. cout << &a << endl; /* 取a的地址十六进制0012FF7C*/  
27.  
28. cout << (int)&a << endl; /*(int)&a:把a的地址强制转换成十进制的整型1245052*/  
29.  
30. cout << (int&)a << endl;</span>  

/*(int&)a:将a的引用强制转换为整型,意思是a所在的内存，本来定义的时候为float类型,并初始为1.0f，

但现在我要按int类型解释这段内存（也就是说a所在的内存地址中的数据本来是按float型存储表示的，你非要按int型来解释不可）。

1.0f 在内存中的存储为 0011 1111 1000 0000 0000 0000 0000 0000. 把他按整型数解释为2^29+2^28+2^27+2^26+2^25+2^24+2^23=1065353216

(int&)a 相当于*(int*)&a ; *(int*)(&a) ; *((int*)&a)

*/

[cpp] view plain copy

1. <span style="font-size:16px;">cout << boolalpha << ((int)a == (int&)a ) << endl;// 输出false.因为1!=1065353216.  
2.  
3.  
4. float b = 0.0f;  
5.  
6. cout << (int)b << endl;//0  
7.  
8. cout << &b << endl;/*取b的地址十六进制0012FF78*/  
9.  
10. cout << (int&)b << endl;//0  
11.  
12. cout << boolalpha << ((int)b == (int&)b ) << endl;// 输出true,因为0==0;</span>  

/*

(int&)a 不经过转换， 直接得到a在内存单元(就是地址)的值

(int)a a在内存中的值转换成int类型

float类型在内存中存储的形式是 ,符号位 指数 尾数

由754标准:阶码采用增码(该数补码的反符号),尾数采用原码

所以1.0f 在内存中的形式为

0011 1111 1000 0000 0000 0000 0000 0000

所以输出的是 0x3f800000

0 在内存中的的存储形式

0000 0000 0000 0000 0000 0000 0000 0000

*/

int& fun1( int & r ){ return r; }

int fun2( void ){ return 10; }

int i = 20;

fun2( ) = 30;                               //A

cout << ( fun1( i ) = 30 );          //B

(  int & )10 = 20;                        //C

( const int & )10 = 20;              //D

( int & )i = 40;                             //E

( double & )i = 50;                     //F

cout << ( double & )i;               //G

A： fun2的返回值是一个右值，不能作为内置赋值表达式的左操作数，因此A是错误的；

B： fun1返回一个引用，属于左值，因此可以作为内置赋值运算符的左操作数；

C： C试图将一个右值强制转换为引用，但是，只有const引用才能引用一个右值，因此错  误；

D： D比C进步了一点，强制转换为const引用，但仍然是错误的，因为const引用属于不可修改的左值，不能通过const引用修改其引用的对象；

E： E将一个int变量强制转换为int引用并被修改。这个表达式容易出现误解，以为i被临时转换为一个引用，其实不然，( int& )i只是产生一个引用到i的临时引用，i是被引用的对象而非引用本身，被修改的是i的值；

F、G：F和G与E一样，都产生一个引用到i的临时引用，但存在两个问题，一是由于i的类型与double&所引用的类型不同，i的底层布局从double&的角度看来是double，F中的50先被转换为double，再存进i，存进i的内容并非int格式的50，而是浮点数格式的50，如果此时打印i的值，结果将为一个“混乱”的整数；二是由于double和int的二进制宽度不一定相同，如果double宽度大于int，则F和G都将导致未定义行为。