【学习笔记】C++ 常量折叠原理和验证

已于 2024-02-18 22:14:25 修改
阅读量449 收藏 6
点赞数 2
分类专栏： Linux 应用开发 文章标签： 学习 笔记 c++
于 2021-06-30 20:06:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovemengx/article/details/118227493
版权

以下的代码很有意思，在相同时刻，相同的内存地址，数据居然会不一样。

#include <iostream>

int main(void)
{
	const int const_val = 3;

	int *nomal_pot = (int*)&const_val;
	*nomal_pot = 9;

	printf("const_val: 0x%p -> %d\n", &const_val, const_val);
	printf("nomal_pot: 0x%p -> %d\n", nomal_pot, *nomal_pot);

	return 0;
}

运行结果： 

const_val: 0x002DF7B0 -> 3
nomal_pot: 0x002DF7B0 -> 9

造成如此神奇的现象，原因是因为 C++ 常量折叠的特性（C没有），这跟 C++ 编译器相关，在编译阶段，会将代码中所有引用该常量的地方，都会替换为常量的初始值，就像宏定义一样，那么上述代码中的第一句代码：

printf("const_val: 0x%p -> %d\n", &const_val, const_val);

会被编译器修改等同为以下代码（实际以汇编体现）： 

printf("const_val: 0x%p -> %d\n", &const_val, 3);

与宏定义不同的是，编译会为常量 const_val 分配内存空间，并且该内存空间处于栈空间，并不是只读的，因此在运行时仍可以通过以下代码修改该内存空间的数据：

int *nomal_pot = (int*)&const_val;
*nomal_pot = 9;

这就出现了同一时间，在相同的 “内存地址” 中输出了不同的值。

以上两点可以通过VS2017查看反汇编的汇编代码即可确认：

#include <iostream>

int main(void)
{
00EA18C0  push        ebp  
00EA18C1  mov         ebp,esp  
00EA18C3  sub         esp,0DCh  
00EA18C9  push        ebx  
00EA18CA  push        esi  
00EA18CB  push        edi  
00EA18CC  lea         edi,[ebp-0DCh]  
00EA18D2  mov         ecx,37h  
00EA18D7  mov         eax,0CCCCCCCCh  
00EA18DC  rep stos    dword ptr es:[edi]  
00EA18DE  mov         eax,dword ptr [__security_cookie (0EAA004h)]  
00EA18E3  xor         eax,ebp  
00EA18E5  mov         dword ptr [ebp-4],eax  
00EA18E8  mov         ecx,offset _2EA97ABB_consoleapplicationtest@cpp (0EAC027h)  
00EA18ED  call        @__CheckForDebuggerJustMyCode@4 (0EA121Ch)  
	const int const_val = 3;
00EA18F2  mov         dword ptr [const_val],3   // 常量赋值为初始值 3 

	int *nomal_pot = (int*)&const_val;
00EA18F9  lea         eax,[const_val]           // 提取常量所在的内存地址
00EA18FC  mov         dword ptr [nomal_pot],eax // 赋给 nomal_pot 指针

	*nomal_pot = 9;
00EA18FF  mov         eax,dword ptr [nomal_pot] // 提取 nomal_pot 指向的内存地址
00EA1902  mov         dword ptr [eax],9  // 往该内存地址写入值 9 (即 const_val 的地址) 

	printf("const_val: 0x%p -> %d\n", &const_val, const_val);
00EA1908  push        3  // 这里可以看到 const_val 直接被替换为初始值 3，并未从地址取值
00EA190A  lea         eax,[const_val]  
00EA190D  push        eax  
00EA190E  push        offset string "const_val: 0x%p -> %d\n" (0EA7B30h)  
00EA1913  call        _printf (0EA104Bh)  
00EA1918  add         esp,0Ch  

	printf("nomal_pot: 0x%p -> %d\n", nomal_pot, *nomal_pot);
00EA191B  mov         eax,dword ptr [nomal_pot]  // 提取 nomal_pot 指向的内存地址
00EA191E  mov         ecx,dword ptr [eax]  // 从该内存地址提取内容，即 9 而非初始值 3
00EA1920  push        ecx  
00EA1921  mov         edx,dword ptr [nomal_pot]  
00EA1924  push        edx  
00EA1925  push        offset string "nomal_pot: 0x%p -> %d\n" (0EA7C04h)  
00EA192A  call        _printf (0EA104Bh)  
00EA192F  add         esp,0Ch  

	return 0;
00EA1932  xor         eax,eax  
}

那么以下代码，你们觉得 add_val 输出的结果会是什么呢？

#include <iostream>

int main(void)
{
	const int const_val = 3;

	int *nomal_pot = (int*)&const_val;
	*nomal_pot = 9;

	printf("const_val: 0x%p -> %d\n", &const_val, const_val);
	printf("nomal_pot: 0x%p -> %d\n", nomal_pot, *nomal_pot);

	int add_val = const_val + *nomal_pot;
	printf("add_val:%d\n", add_val);

	return 0;
}

按照上述分析，源码中所有对 const_val 的引用都会在编译期间替换为初始值，而 const_val 所在的内存空间是可以在运行时被修改，因此正确的答案应为 3 + 9 = 12

const_val: 0x0036FDC4 -> 3
nomal_pot: 0x0036FDC4 -> 9
add_val:12

对应的汇编代码：

#include <iostream>

int main(void)
{
001218C0  push        ebp  
001218C1  mov         ebp,esp  
001218C3  sub         esp,0E8h  
001218C9  push        ebx  
001218CA  push        esi  
001218CB  push        edi  
001218CC  lea         edi,[ebp-0E8h]  
001218D2  mov         ecx,3Ah  
001218D7  mov         eax,0CCCCCCCCh  
001218DC  rep stos    dword ptr es:[edi]  
001218DE  mov         eax,dword ptr [__security_cookie (012A004h)]  
001218E3  xor         eax,ebp  
001218E5  mov         dword ptr [ebp-4],eax  
001218E8  mov         ecx,offset _2EA97ABB_consoleapplicationtest@cpp (012C027h)  
001218ED  call        @__CheckForDebuggerJustMyCode@4 (012121Ch)  
	const int const_val = 3;
001218F2  mov         dword ptr [const_val],3  

	int *nomal_pot = (int*)&const_val;
001218F9  lea         eax,[const_val]  
001218FC  mov         dword ptr [nomal_pot],eax  
	*nomal_pot = 9;
001218FF  mov         eax,dword ptr [nomal_pot]  
00121902  mov         dword ptr [eax],9  

	printf("const_val: 0x%p -> %d\n", &const_val, const_val);
00121908  push        3  
0012190A  lea         eax,[const_val]  
0012190D  push        eax  
0012190E  push        offset string "const_val: 0x%p -> %d\n" (0127B30h)  
00121913  call        _printf (012104Bh)  
00121918  add         esp,0Ch  
	printf("nomal_pot: 0x%p -> %d\n", nomal_pot, *nomal_pot);
0012191B  mov         eax,dword ptr [nomal_pot]  
0012191E  mov         ecx,dword ptr [eax]  
00121920  push        ecx  
00121921  mov         edx,dword ptr [nomal_pot]  
00121924  push        edx  
00121925  push        offset string "nomal_pot: 0x%p -> %d\n" (0127C04h)  
0012192A  call        _printf (012104Bh)  
0012192F  add         esp,0Ch  

	int add_val = const_val + *nomal_pot;
00121932  mov         eax,dword ptr [nomal_pot]  // 提取 nomal_pot 所指向的内存地址 
00121935  mov         ecx,dword ptr [eax]  // 从该内存地址中提取数值(即9)
00121937  add         ecx,3  // 将该数值与 3 相加（即 9 + 3）
0012193A  mov         dword ptr [add_val],ecx  // 将结果写入 add_val (即 12) 
	printf("add_val:%d\n", add_val);
0012193D  mov         eax,dword ptr [add_val]  
00121940  push        eax  
00121941  push        offset string "add_val:%d\n" (0127B48h)  
00121946  call        _printf (012104Bh)  
0012194B  add         esp,8  

	return 0;
0012194E  xor         eax,eax  
}

那再略微修改一下，const 增加 volatile 修饰符，输出结果会是一样吗？

#include <iostream>

int main(void)
{
	volatile const int const_val = 3;  // 增加 volatile 修饰符

	int *nomal_pot = (int*)&const_val;
	*nomal_pot = 9;

	printf("const_val: 0x%p -> %d\n", &const_val, const_val);
	printf("nomal_pot: 0x%p -> %d\n", nomal_pot, *nomal_pot);

	int add_val = const_val + *nomal_pot;
	printf("add_val:%d\n", add_val);

	return 0;
}

输出结果： 

const_val: 0x0039F8F8 -> 9
nomal_pot: 0x0039F8F8 -> 9
add_val:18

原因是因为经过 volatile 修饰的变量会明确让编译器编译代码时，每次都要求生成的汇编语句都是从该变量的地址中取出数据，而不是用常量值替代，这个可以通过反汇编证实这一点：

差异的点：


// 原来的 ------------------------------------------------------------------------
	printf("const_val: 0x%p -> %d\n", &const_val, const_val);
00121908  push        3  // 这里可以看到 const_val 直接被替换为初始值 3，并未从地址取值
0012190A  lea         eax,[const_val]  
0012190D  push        eax  
0012190E  push        offset string "const_val: 0x%p -> %d\n" (0127B30h)  
00121913  call        _printf (012104Bh)  
00121918  add         esp,0Ch

......

	int add_val = const_val + *nomal_pot;
00121932  mov         eax,dword ptr [nomal_pot]  // 提取 nomal_pot 所指向的内存地址 
00121935  mov         ecx,dword ptr [eax]  		 // 从该内存地址中提取数值(即9)
00121937  add         ecx,3  					 // 将该数值与 3 相加（即 9 + 3）
0012193A  mov         dword ptr [add_val],ecx  	 // 将结果写入 add_val (即 12)

// 现在的 ------------------------------------------------------------------------
	printf("const_val: 0x%p -> %d\n", &const_val, const_val);
01151908  mov         eax,dword ptr [const_val]  // 注意，这里改从该内存地址取值
0115190B  push        eax  
0115190C  lea         ecx,[const_val]  
0115190F  push        ecx  
01151910  push        offset string "const_val: 0x%p -> %d\n" (01157B30h)  
01151915  call        _printf (0115104Bh)  
0115191A  add         esp,0Ch  

......

	int add_val = const_val + *nomal_pot;
01151934  mov         eax,dword ptr [const_val]  // 提取 const_val 所指向的内存地址 
01151937  mov         ecx,dword ptr [nomal_pot]	 // 提取 nomal_pot 所指向的内存地址  
0115193A  add         eax,dword ptr [ecx]  		 // 注意，将两者数据相加(即 9 + 9)
0115193C  mov         dword ptr [add_val],eax 	 // 将结果写入到 add_val (即 18)

完整汇编：

#include <iostream>

int main(void)
{
011518C0  push        ebp  
011518C1  mov         ebp,esp  
011518C3  sub         esp,0E8h  
011518C9  push        ebx  
011518CA  push        esi  
011518CB  push        edi  
011518CC  lea         edi,[ebp-0E8h]  
011518D2  mov         ecx,3Ah  
011518D7  mov         eax,0CCCCCCCCh  
011518DC  rep stos    dword ptr es:[edi]  
011518DE  mov         eax,dword ptr [__security_cookie (0115A004h)]  
011518E3  xor         eax,ebp  
011518E5  mov         dword ptr [ebp-4],eax  
011518E8  mov         ecx,offset _2EA97ABB_consoleapplicationtest@cpp (0115C027h)  
011518ED  call        @__CheckForDebuggerJustMyCode@4 (0115121Ch)  
	volatile const int const_val = 3;
011518F2  mov         dword ptr [const_val],3  

	int *nomal_pot = (int*)&const_val;
011518F9  lea         eax,[const_val]  
011518FC  mov         dword ptr [nomal_pot],eax  
	*nomal_pot = 9;
011518FF  mov         eax,dword ptr [nomal_pot]  
01151902  mov         dword ptr [eax],9  

	printf("const_val: 0x%p -> %d\n", &const_val, const_val);
01151908  mov         eax,dword ptr [const_val]  
0115190B  push        eax  
0115190C  lea         ecx,[const_val]  
0115190F  push        ecx  
01151910  push        offset string "const_val: 0x%p -> %d\n" (01157B30h)  
01151915  call        _printf (0115104Bh)  
0115191A  add         esp,0Ch  
	printf("nomal_pot: 0x%p -> %d\n", nomal_pot, *nomal_pot);
0115191D  mov         eax,dword ptr [nomal_pot]  
01151920  mov         ecx,dword ptr [eax]  
01151922  push        ecx  
01151923  mov         edx,dword ptr [nomal_pot]  
01151926  push        edx  
01151927  push        offset string "nomal_pot: 0x%p -> %d\n" (01157C04h)  
0115192C  call        _printf (0115104Bh)  
01151931  add         esp,0Ch  

	int add_val = const_val + *nomal_pot;
01151934  mov         eax,dword ptr [const_val]  
01151937  mov         ecx,dword ptr [nomal_pot]  
0115193A  add         eax,dword ptr [ecx]  
0115193C  mov         dword ptr [add_val],eax  
	printf("add_val:%d\n", add_val);
0115193F  mov         eax,dword ptr [add_val]  
01151942  push        eax  
01151943  push        offset string "add_val:%d\n" (01157B48h)  
01151948  call        _printf (0115104Bh)  
0115194D  add         esp,8  

	return 0;
01151950  xor         eax,eax  
}

lovemengx
关注
专栏目录
C++ 常量折叠问题的理解
MISAYAONE的博客
04-08 1232
在C++中，const变量(即常量)值放在编译器的符号表中，计算时编译器直接从表中取值，而不是访问内存，省去了访问内存的时间，这也就是所谓的编译器优化。 下面的代码可以很清晰的看出： main.cpp #include using namespace std; int main(int argc,char** argv) { /*volatile*/ const int i = 0;
C++常量折叠
热门推荐
03-16 1万+
今天回顾了大学这几年学习C++的点点滴滴，在回顾了“常量折叠”这里时，突然困惑了，当时学习这点知识时的理解是：可折叠的常量像宏一样，在预编译阶段对常量的引用一律被替换为常量所对应的值，就和普通的宏替换没什么区别，并且，编译器不会为该常量分配空间。现在回顾起来，当时是多么的天真，被现象迷惑了，常量折叠确实会像宏一样把对常量的引用替换为常量对应的值，但是，并非不给该常量分配空间，如下代码： #d
C++中的常量折叠
weixin_30521161的博客
04-01 99
　　先看例子： #include <iostream> using namespace std; int main() { const int a = 10; int * p = (int *)(&a); *p = 20; cout<<"a = "<<a<<", *p = ...
[C++ 学习] 常量折叠
杂七杂八
04-06 613
转载自 http://www.cnblogs.com/chenyuming507950417/   所谓 "常量折叠",就是 const 类型的变量,在使用这个变量的时候,无视这快内存内容是什么, 而是直接使用这个变量最开始的初始值.   下面是转载的内容 :     今天意外见识了这个名词是在CSDN帖子里http://topic.csdn.net/u/20120406/03/
常量折叠
masic007のlogs
09-24 1206
首先来看一个例子： int main(int argc, char* argv[]) { const int i=0; int *j = (int *) &i; *j=1; cout cout cout return 0; } 结果是 0012ff7c
C++ 学习笔记
腾讯技术工程
02-28 1853
作者：readywang(王玉龙)template 是 c++ 相当重要的组成部分，堪称 c++语言的一大利器。在大大小小的 c++ 程序中，模板无处不在。c++ templates 作为...
[学习笔记]现代c++11/14/17总结
pwjworks的博客
08-05 242
语言可用性的强化 常量 nullptr 传统c++会把NULL、0解析成一种东西，有些编译器会把NULL定义成((void*)0)或者0。使用NULL调用函数会导致c++重载特性混乱。比如： void foo(char*), void foo(int) foo(NULL)会调用foo(int). C++11 引入了 nullptr 关键字，专门用来区分空指针、0。而 nullptr 的类型为 nullptr_t，能够隐式的转换为任何指针或成员指针的类型，也能和他们进行相等或者不等的比较。 const
C++ Primer（读书笔记）
汪子涵的博客
07-03 909
整型字面值：以0开头的整数代表八进制数，以0x或0X开头的代表十六进制，对应20、024、0x14，默认情况下，十进制字面值时带符号值，八进制和十六进制字面值即可能是带符号的也可能是无符号的。八进制和十六进制字面值的类型时能容纳其数值的int、unsigned int、long、unsigned long、long long、unsigned long long中的尺寸最小者。在C++中，我们要尽量避免依赖于实现环境的行为，如果我们把int的尺寸看成是一个确定不变的已知值，那么这样的程序是不可移植的。
g++/gcc指令详解--学习笔记
最新发布
qq_61337486的博客
07-23 1032
选择优化等级应根据具体需求进行权衡。开发和调试阶段通常使用-O0，而在发布和生产环境中可以选择-O2或-O3以获取更高的性能。如果代码大小是关键因素，可以选择-Os。对于追求极致性能且能接受标准兼容性问题的场景，可以考虑-Ofast。每种优化等级都有其适用场景和权衡点，选择时需综合考虑编译时间、运行性能和调试需求。g++ -D<宏> source_file.cppgcc -D<宏> source_file.cint main()#endifreturn 0;
C++学习笔记（面向对象部分开始6500字复习总结）
deligent_torche的博客
11-21 440
读取一个类型的虚函数表需要将类的类型转换为指针类型，此处感悟，程序中数据的运算形式（即运算符的操作形式）是由该变量的类型决定，int也可以看做一个变量，它是定义int类的那一块空间的地址，将int转换为void *，就可以访问int类定义的地址了，类比自定义的类结构，访问类定义的地址后，前8个字节就是虚函数表的首地址，再对首地址进行遍历函数接口，就可以输出所有的函数了。《个人理解》当需要调用拷贝构造时，就一直往前传递this地址指针，省掉中间的拷贝构造，直接让对应接口的构造函数在目标对象的地址上进行构造。
c++的常量折叠
feng__shuai的博客
11-11 528
开会的时候听到一耳朵，不知道是啥，查了一下感觉还挺有意思的，以前也没注意过。 例子 #include "stdio.h" #define PI 3.14 int main() { double pi = PI; const int i = 0; int *j = (int *) &i; *j = 1; printf("0x%p\n0x%p\n%d\n%d\n",&i,j,i,*j); //观看实
c++常量折叠(常量替换)
yiruirui0507的专栏
07-02 1046
<br /> <br />#include<iostream><br />usingnamespacestd;<br /> <br />voidmain()<br />{<br />    constinta = 5;<br />    int *p = (int *)&a; //让p指向与a相同的内存空间<br />    cout << &a << ", " << p << endl;<br /> <br />    *p = 10; // 照里说a的值也应该改变，实际却没有,这就是常量折叠.<br /
C++中的常量折叠问题
peixuan的专栏
08-31 1057
最近做了一道笔试题才发现了这个问题 题目： const int a = 10;// 这这里声明的变量a 就会产生常量重叠。 int *p = (int *)&a; *p = 20; cout << "a= " << a << endl << "p= " << *p; return 0; 那么大家想想正确的输出结果是什么？ a= 10 *p = 20 为什么两个指向同一个地址
C++学习记录 - 常量折叠
行仔ovo的博客
06-24 592
转自：https://www.cnblogs.com/stemon/p/4406824.html 0.前言 前几天女票问了我一个阿里的面试题，是有关C++语言的const常量的，其实她一提出来我就知道考察的点了：肯定是const常量的内存不是分配在read-only的存储区的，const常量的内存分配区是很普通的栈或者全局区域。也就是说const常量只是编译器在编译的时候做检查，根本不存在什么read-only的区域。 所以说C++的const常量和常量字符串是不同的，常量字符串是存储在read-only的
c++中的常量折叠
boboboke
06-03 1145
何谓常量折叠？ 常量折叠就是将常量表达式计算求值，并用求得的值来替换表达式，放入常量表。可以算作一种编译优化。（预编译阶段）接下来我们通过一段代码来分析一下了解一下常量折叠及其特性：int main() { const int a = 10; int b = 2*a; int c = b; int *p = (int*)&a; *p = 100; c
C++学习笔记：常量、函数模板与对象地址
"C++学习笔记，涵盖C++的定义、使用中的注意事项以及C++与C的关系，强调面向对象编程，并提供了课程的相关信息，包括教材、课时安排、考核方式等。" 在C++学习中，定义及使用时需要注意的问题是多方面的。例如，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值