企业官网建设流程全解析

很多初学者在学习 C++ 面向对象时，脑海里都会有一个疑问：“既然每个对象都有自己的变量，那类里面的函数是放在哪里的？如果函数是共享的，它怎么知道我现在操作的是哪个对象的数据？”

今天，我们就从 C++ 的四大内存分区说起，扒开编译器的外衣，彻底搞懂对象与this指针的底层逻辑。

一、 C++ 的四大内存分区

在 C++ 程序运行时，操作系统会为程序分配内存，并将内存划分为四个主要区域。理解这四个区，是理解面向对象底层逻辑的前提：

1. 代码区（Code Segment）：存放程序执行的二进制机器指令（包括你写的所有函数、类的方法）。这一块是只读且共享的。

2. 全局/数据区（Data Segment）：存放全局变量、静态变量（static）以及常量。程序结束后由系统释放。

3. 栈区（Stack）：存放函数内部的局部变量、形参。由编译器自动分配和释放，速度快但空间有限。我们平时直接ABC a;创建的对象就存在这里。

4. 堆区（Heap）：由程序员手动分配和释放的内存（使用new/delete）。空间大但速度相对较慢。

💻代码验证：对象存在哪？

#include <iostream> using namespace std; int global_var = 10; // 存放在【全局/数据区】 class ABC { public: int n; }; int main() { ABC a; // 局部对象 a，存放在【栈区】 ABC* b = new ABC(); // b 本身是一个指针变量存放在【栈区】，但它指向的 ABC 对象存放在【堆区】 cout << "全局变量地址 (数据区): " << &global_var << endl; cout << "局部对象 a 地址 (栈区): " << &a << endl; cout << "动态对象 b 地址 (堆区): " << b << endl; delete b; return 0; }

二、 对象的内存占用：只有数据，没有代码

每创建一个对象，系统只会在内存（如栈区）中为这个对象的数据（成员变量）分配空间，而绝不会为函数分配空间。

类中声明的函数（包括普通函数、构造函数、析构函数）全部被编译成指令，统一存放在代码区。无论你创建了 1 个对象还是 1000 个对象，这些函数在内存中永远只有一份，被所有对象共享使用。

💻代码验证：用sizeof证明函数不占对象内存

#include <iostream> using namespace std; class EmptyClass {}; class DataClass { public: int n; // 占 4 字节 }; class FuncClass { public: int n; // 占 4 字节 // 下面写了一堆函数 FuncClass() {} ~FuncClass() {} void doSomething1() {} void doSomething2() {} }; int main() { // 空类通常占 1 字节（为了在内存中有独一无二的地址） cout << "EmptyClass 大小: " << sizeof(EmptyClass) << endl; cout << "DataClass 大小: " << sizeof(DataClass) << endl; // 输出 4 // FuncClass 里面多了那么多函数，大小依然是 4 字节！ // 这证明了：函数根本不存在于对象内部，而是剥离出去存放在了代码区。 cout << "FuncClass 大小: " << sizeof(FuncClass) << endl; return 0; }

三、 this 指针：

既然函数只有一份，存在代码区，供所有对象共同调用。那么问题来了： 当执行obj1.set_n(10)和obj2.set_n(20)时，同一份代码是怎么知道应该去修改obj1的内存，还是去修改obj2的内存呢？

答案就是：C++ 编译器在底层通过隐藏的this指针做了手脚！

1. 编译器的“暗箱操作”

当你在 C++ 中写下这样的代码：

class ABC { public: int n; void set_n(int val) { n = val; // 你以为就这么简单？ } }; int main() { ABC a; a.set_n(100); return 0; }

在底层（例如g++编译时），编译器会把这段 C++ 面向对象代码，翻译成类似 C 语言的面向过程代码。

翻译步骤如下：

1. 给函数增加一个隐藏的参数：编译器会悄悄把调用该函数的对象的地址传进去。这个隐藏参数的类型是ABC* const this（一个常量指针，指向当前对象，指针本身不能改变指向）。

2. 在函数内部替换变量名：把类内部所有的成员变量前面，强制加上this->。

3. 在调用处传递地址：把你写的a.set_n(100)翻译成set_n(&a, 100)。

2. 揭开伪装：底层的真实面貌

上面那段代码，在编译器眼里的真实模样其实是这样的（伪代码）：

// 1. 结构体只保留数据 struct ABC { int n; }; // 2. 函数被剥离出来，并被强行塞入了一个 this 指针作为第一个参数！ // 注意 this 的类型是：类名* const void ABC_set_n(ABC* const this, int val) { this->n = val; // 3. 内部自动加上 this-> } int main() { ABC a; // 4. 调用函数时，编译器偷偷把对象 a 的地址（&a）传给了 this 指针 ABC_set_n(&a, 100); return 0; }

3. this 指针的本质与限制

通过上面的底层翻译，我们可以总结出this指针的几个核心特征：

• this本质上是一个隐藏的函数形参，它并不存在于对象内部，不占用对象的存储空间。

• 它的精确类型是类类型* const。这意味着在函数内部，你可以改变对象的值（如this->n = 10），但你绝对不能改变this指针的指向（比如不能写this = &another_obj）。

• 因为它是隐藏形参，所以只有在非静态（non-static）成员函数内部才能使用this指针。