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

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,0Ch

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

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

#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－