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
}汇编代码：
5: const int val = 10; // 常量，有类型，可寻址，但使用时并不通过内存引用
00401048 mov dword ptr [ebp-4],0Ah // val有在栈帧上分配内存空间
6: int* p = (int*)&val; // 直接更新val会报错，可通过指针间接获取地址
0040104F lea eax,[ebp-4]
00401052 mov dword ptr [ebp-8],eax
7: *p += 10; // 更改p或&val内存地址所在内存的值
00401055 mov ecx,dword ptr [ebp-8]
00401058 mov edx,dword ptr [ecx]
0040105A add edx,0Ah // 在这里直接使用字面值10，并不是通过内存访问获取值
0040105D mov eax,dword ptr [ebp-8] // 这里更新的是&val所在值
00401060 mov dword ptr [eax],edx
8: printf("val = %d *p = %d\n", val, *p); //val = 10 *p = 20
00401062 mov ecx,dword ptr [ebp-8]
00401065 mov edx,dword ptr [ecx]
00401067 push edx
00401068 push 0Ah // 这里也是直接使用字面值
0040106A push offset string "val = %d *p = %d\n" (00431024)
0040106F call printf (004081f0)
00401074 add esp,0Ch
9: int sum = val + 3; // 对val引用的并不是通过内存地址
00401077 mov dword ptr [ebp-0Ch],0Dh // 这里也是优化为一个直接值：10+3
10: int add = *p + 4; // 对&val（p）内存地址的值的引用
0040107E mov eax,dword ptr [ebp-8]
00401081 mov ecx,dword ptr [eax]
00401083 add ecx,4
00401086 mov dword ptr [ebp-10h],ecx
11: printf("%d %d\n",sum,add); //13 20
00401089 mov edx,dword ptr [ebp-10h]
0040108C push edx
0040108D mov eax,dword ptr [ebp-0Ch]
00401090 push eax
00401091 push offset string "%d %d\n" (0043101c)
00401096 call printf (004081f0)
0040109B add esp,0Ch2 对象初始化及构造函数调用
编译器的优化处理，可以绕过拷贝构造函数。
#include
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< 从输出结果可见，其拷贝控制函数并没有预想的多次调用，编译器会视情况做一定程度的优化。
3 不使用实例来调用成员函数
对于类的成员函数地址，可以通过取成员函数的地址，赋给一个类作用域的函数指针，通过汇编代码可以将此函数地址再赋值给一个普通的函数指针，这个函数指针可以调用类成员函数。
#include
#include
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< ref
换个视角看问题，深挖关于操作系统三个诡异问题的底层逻辑 【C/C++】
https://www.bilibili.com/video/BV1Kv411W7sb?spm_id_from=333.999.0.0
－End－