地址一样基本类型差不多，值却不一样，编译器如何实现的？

[执假以为真]

请看代码，问题在代码中：

#include <iostream>
using namespace std;

int main()
{
  const int a = 1;
  int & b = const_cast<int &>(a);
  cout<<a<<" "<<b<<endl; // 1 1
  b=10;
  cout<<a<<" "<<b<<endl; // 1 10  
  
  // 以上a和b的值不一样，但打印出的地址是相同的，这是如何做到的呢？？
  cout << "Address of a is " << reinterpret_cast<int>(&a) <<endl;
  cout << "Address of b is " << reinterpret_cast<int>(&b) <<endl;
  
  return 0;
} 

[qiminixi]

引用 4 楼 baichi4141 的回复:

编译器在编译的时候，发现a是常量，于是就把所有使用a的地方直接替换成a的初值 它没想到这世上还有某些程序员，喜欢一边定义常量一边想方设法修改常量——或许它想到了，只是觉得这种程序员自作自受它没必要去理睬

有这个可能我也懒得去猜测编译器的实现机制，也猜不出什么结果，懂编译器的大神出来冒个泡呗 可以翻翻汇编代码看看是怎么回事

[疯狂的红豆]

#include <iostream> using namespace std; int main() { const int a = 1; int & b = const_cast<int &>(a); cout<<a<<" "<<b<<endl; // 1 1 b=10; //这句代码起作用是在运行期 cout<<a<<" "<<b<<endl; // 1 10 //a是个可折叠常量，上面代码在编译期间a就已经被替换成了1了 //所以代码中任何的有关常量a的引用都会在编译期被替换掉 // 以上a和b的值不一样，但打印出的地址是相同的，这是如何做到的呢？？ cout << "Address of a is " << reinterpret_cast<int>(&a) <<endl; cout << "Address of b is " << reinterpret_cast<int>(&b) <<endl; return 0; }

[一入程序深似海]

b是a的一个引用。。把b和a换成指针看看 int* b = const_cast<int *>(&a);

[帅得不敢出门]

常量折叠。。。。。。

[我看你有戏]

#include "stdafx.h"

#include <iostream>
using namespace std;

int main()
{
	const int a = 1;
	printf("&a = 0x%p\n",&a);


	int* pa = const_cast<int *>(&a);
	int & b = const_cast<int &>(a);

	// 以上a和b的值不一样，但打印出的地址是相同的，这是如何做到的呢？？

	printf("&a = 0x%p,pa=0x%p\n",&a,pa);
	printf("&b = 0x%p\n",&b);

	printf("reinterpret_cast<int>(&a) = 0x%p\n",reinterpret_cast<int>(&a));
	printf("reinterpret_cast<int>(&b) = 0x%p\n",reinterpret_cast<int>(&b));


	cout<<a<<" "<<b<<endl; // 1 1
	b=10;
	//cout<<a<<" "<<b<<endl; // 1 10  
	//cout<<a<<" "<<b<<endl; // 1 10  
	int c = a;
	printf("%d,%d,%d",a,b,c);

	// 以上a和b的值不一样，但打印出的地址是相同的，这是如何做到的呢？？
	printf("&a = %p\n",&a);
	printf("&b = %p\n",&b);

	printf("reinterpret_cast<int>(&a) = 0x%p\n",reinterpret_cast<int>(&a));
	printf("reinterpret_cast<int>(&b) = 0x%p\n",reinterpret_cast<int>(&b));



	return 0;
} 

试了试水，很深，正如楼主所说

[baichi4141]

编译器在编译的时候，发现a是常量，于是就把所有使用a的地方直接替换成a的初值 它没想到这世上还有某些程序员，喜欢一边定义常量一边想方设法修改常量——或许它想到了，只是觉得这种程序员自作自受它没必要去理睬

[执假以为真]

又做了个有趣的实验

#include <iostream>
using namespace std;

int main()
{
  const int a = 0;
  int & b1 = const_cast<int &>(a);
  b1=1;
  int & b2 = const_cast<int &>(a);
  b2=2;
  int & b3 = const_cast<int &>(a);
  b3=3;
  
  cout<<a<<" "<<b1<<" "<<b2<<" "<<b3<<endl; // 0 3 3 3
   
  cout << "Address of a is " << reinterpret_cast<int>(&a) <<endl;
  cout << "Address of b1 is " << reinterpret_cast<int>(&b1) <<endl;
  cout << "Address of b2 is " << reinterpret_cast<int>(&b2) <<endl;
  cout << "Address of b3 is " << reinterpret_cast<int>(&b3) <<endl;
  
  return 0;
} 

多谢星星给出关键词“常量折叠”。

[执假以为真]

哦，这下应该明白了。因为那个常量的地址毕竟只有一个，所以b1 b2 b3对其的修改，最终导致b1 b2 b3的值只能是最后一次修改的值，即b3的值3。而a是常量，早就被替换了，所以有a的地方，永远都是a的初始值0.