C++｜从内存和汇编角度理解const及不通过类变量直接调用成员函数

欢迎大家来到IT世界,在知识的湖畔探索吧!

C号称面向内存编程，自然C++也是如此。从内存和汇编的角度看C++的一些语法设计，可以更深刻地理解其底层逻辑。

我们知道，编程语言的抽象程度，语法越复杂，编译器做的事情也越多。如虚函数技术，编译器要为每个含有虚函数的类建立虚函数表，在含有虚函数的类对象的内存空间有前面增加一个虚函数指针，以及实现动态类型识别。所谓的“语法糖”就是这种现象，如操作符pobj->mem其实就是*(pobj).mem的语法糖，arr[i]就是*(arr+i)的语法糖。

C++的类的语法机制，最终也要化类对象的成员函数为普通函数，背后也是编译器的动作。

1 const常量的底层处理

const常量会分配内存，但其引用并不是通过引用内存地址对应的位置的值，而是直接引用常量值。

void test() { const int val = 10; // 常量，有类型，可寻址， // 但使用时并不通过内存引用 int* p = (int*)&val; // 直接更新val会报错，可通过指针间接获取地址 *p += 10; // 更改p或&val内存地址所在内存的值 printf("val = %d *p = %d\n", val, *p); //val = 10 *p = 20 int sum = val + 3; // 对val引用的并不是通过内存地址 int add = *p + 4; // 对&val（p）内存地址的值的引用 printf("%d %d\n",sum,add); //13 20 }

欢迎大家来到IT世界,在知识的湖畔探索吧!

汇编代码：

欢迎大家来到IT世界,在知识的湖畔探索吧!5: const int val = 10; // 常量，有类型，可寻址，但使用时并不通过内存引用 00 mov dword ptr [ebp-4],0Ah // val有在栈帧上分配内存空间 6: int* p = (int*)&val; // 直接更新val会报错，可通过指针间接获取地址 0040104F lea eax,[ebp-4] 00 mov dword ptr [ebp-8],eax 7: *p += 10; // 更改p或&val内存地址所在内存的值 00 mov ecx,dword ptr [ebp-8] 00 mov edx,dword ptr [ecx] 0040105A add edx,0Ah // 在这里直接使用字面值10，并不是通过内存访问获取值 0040105D mov eax,dword ptr [ebp-8] // 这里更新的是&val所在值 00 mov dword ptr [eax],edx 8: printf("val = %d *p = %d\n", val, *p); //val = 10 *p = 20 00 mov ecx,dword ptr [ebp-8] 00 mov edx,dword ptr [ecx] 00 push edx 00 push 0Ah // 这里也是直接使用字面值 0040106A push offset string "val = %d *p = %d\n" (00) 0040106F call printf (004081f0) 00 add esp,0Ch 9: int sum = val + 3; // 对val引用的并不是通过内存地址 00 mov dword ptr [ebp-0Ch],0Dh // 这里也是优化为一个直接值：10+3 10: int add = *p + 4; // 对&val（p）内存地址的值的引用 0040107E mov eax,dword ptr [ebp-8] 00 mov ecx,dword ptr [eax] 00 add ecx,4 00 mov dword ptr [ebp-10h],ecx 11: printf("%d %d\n",sum,add); //13 20 00 mov edx,dword ptr [ebp-10h] 0040108C push edx 0040108D mov eax,dword ptr [ebp-0Ch] 00 push eax 00 push offset string "%d %d\n" (0043101c) 00 call printf (004081f0) 0040109B add esp,0Ch

2 对象初始化及构造函数调用

编译器的优化处理，可以绕过拷贝构造函数。

#include <iostream> using namespace std; class A{ public: A(){ printf("%s(%d):%s\n",__FILE__,__LINE__,__FUNCTION__); } A(int num):data(num){ printf("%s(%d):%s\n",__FILE__,__LINE__,__FUNCTION__); } A(const A& a){ printf("%s(%d):%s\n",__FILE__,__LINE__,__FUNCTION__); data = a.data; } A& operator=(const A& a){ printf("%s(%d):%s\n",__FILE__,__LINE__,__FUNCTION__); if(this!=&a){ data = a.data; } return *this; } int data; }; A t(A a){ A temp = a; temp.data += 10; return temp; } void test01(){ A temp = t(5); cout<<temp.data<<endl; } int main() { test01(); return 0; } /*输出 main.cpp(9):A main.cpp(12):A 15 */

从输出结果可见，其拷贝控制函数并没有预想的多次调用，编译器会视情况做一定程度的优化。

3 不使用实例来调用成员函数

对于类的成员函数地址，可以通过取成员函数的地址，赋给一个类作用域的函数指针，通过汇编代码可以将此函数地址再赋值给一个普通的函数指针，这个函数指针可以调用类成员函数。

欢迎大家来到IT世界,在知识的湖畔探索吧!#include <iostream> #include <string.h> using namespace std; class A{ public: A(){ printf("%s(%d)\n",__FILE__,__LINE__); } A(int num):data(num){ printf("%s(%d)\n",__FILE__,__LINE__); } A(const A& a){ printf("%s(%d)\n",__FILE__,__LINE__); data = a.data; } A& operator=(const A& a){ printf("%s(%d)\n",__FILE__,__LINE__); if(this!=&a){ data = a.data; } return *this; } void test(){ // arm编译器 this是参数0 x86是ecx寄存器 printf("%s(%d) data=%d\n",__FILE__,__LINE__,data); } static void test_(){ printf("%s(%d)\n",__FILE__,__LINE__); } int data; }; A t(A a){ A temp = a; temp.data += 10; return temp; } void test01(){ A temp = t(5); cout<<temp.data<<endl; } typedef void(*TestFunc)(); void test02(){ A a(10),b(11); TestFunc p = NULL; void(A::*tmp)() = &A::test; memcpy(&p,&tmp,sizeof(tmp)); __asm lea ecx, a; p(); a.test(); b.test(); a.test_(); b.test_(); A::test_(); } int main() { test02(); while(1); return 0; } /* F:\Website\notes\test\test.cpp(10) F:\Website\notes\test\test.cpp(10) F:\Website\notes\test\test.cpp(24) data=10 F:\Website\notes\test\test.cpp(24) data=10 F:\Website\notes\test\test.cpp(24) data=11 F:\Website\notes\test\test.cpp(27) F:\Website\notes\test\test.cpp(27) F:\Website\notes\test\test.cpp(27) */

ref

换个视角看问题，深挖关于操作系统三个诡异问题的底层逻辑 【C/C++】

https://www.bilibili.com/video/BV1Kv411W7sb?spm_id_from=333.999.0.0

－End－