在C++中，变量的存储位置取决于它们的类型和生命周期。那么不同的各个变量究竟存储在哪个区域呢？
1.不同类型的变量
我们首先从变量类型的不同来说明：
1. 全局变量和静态变量
- 存储区：全局/静态区（静态区）
- 说明：全局变量（包括文件级和函数级的）和使用 `static` 关键字声明的变量存储在静态区中。它们在程序启动时被分配，并在程序结束时销毁，具有整个程序的生命周期。
int globalVar; // 全局变量
int main()
{
static int staticVar; // 静态变量
return 0;
}2. 局部变量
- 存储区：栈区（Stack）
- 说明：局部变量是在函数或代码块内部声明的变量。它们在函数执行时分配，在函数退出后销毁。栈区的分配和释放速度很快，但栈区的大小有限。
void func() {
int localVar; // 局部变量
}3. 动态分配的变量
- 存储区：堆区（Heap）
- 说明：通过 new、malloc等动态分配的变量存储在堆区中。堆区的内存由程序员手动管理，使用 new分配后需要手动 delete，malloc分配后需要 free释放，否则可能会导致内存泄漏。
int* p = new int; // 动态分配的变量
delete p;
指针变量p作为局部变量存储在栈区
，p通过new分配的内存空间在堆区4. 常量
- 存储区：常量存储区（常量区）
- 说明：字符串常量和const修饰的全局变量等通常存储在常量区。这个区域是只读的，无法修改。
const int constVar = 100; // 常量
constVar是一个const修饰的局部变量，存储在栈区，100存储在
程序的只读数据段（常量区）
const char* str = "Hello"; // 字符串常量
str是一个局部变量，存储在栈区，它保存的是字符串常量“hello”
的地址，“hello”存储在产量区（也称只读数据区），因为他是不
可修改的字符串的字面值5. 函数参数
- 存储区：栈区（Stack）
- 说明：函数参数在函数调用时压入栈中，当函数返回时这些参数被销毁。
6. 静态局部变量
- 存储区：全局/静态存储区（静态区）
- 说明：静态局部变量只在函数中初始化一次，并在整个程序运行期间保留它的值，但它的作用域仍然在定义它的函数中。
void func() {
static int staticLocalVar = 0; // 静态局部变量
}2.内存分配区域
我们再从内存分配的5个主要区域来说明：
1. 栈区（Stack Segment）：局部变量、函数参数、返回地址。
2. 堆区（Heap Segment）：动态分配的内存。
3. 全局/静态存储区（Data Segment）：
- 已初始化数据段：已初始化的全局变量和静态变量。
- 未初始化数据段：未初始化的全局变量和静态变量。
4. 常量区（Text/ROData Segment）：字符串常量、`const` 修饰的全局常量。
5. 代码区（Code Segment or Text Segment）：存储程序的可执行代码。
接下来我们来详细介绍这五块区域：
1. 栈区（Stack Segment）
- 特点：用于存储局部变量、函数参数和返回地址。栈上的内存分配是自动管理的，即由编译器在函数调用时自动分配并在函数返回时自动释放。
- 分配方式：由系统自动分配和释放，遵循后进先出（LIFO）的原则。
- 优点：分配和释放速度非常快。
- 缺点：栈空间有限，局部变量和函数调用较多时可能会导致栈溢出。
- 典型使用：局部变量、函数参数。
#include <iostream>
using namespace std;
void func(int param) {
// 局部变量，存储在栈区
int localVar = 10;
// 输出局部变量和参数的地址
cout << "Address of localVar (栈区局部变量): " << &localVar << endl;
cout << "Address of param (栈区函数参数): " << ¶m << endl;
}
int main() {
// 局部变量，存储在栈区
int mainVar = 20;
// 调用函数 func，并传递一个参数
func(mainVar);
// 输出 mainVar 的地址
cout << "Address of mainVar (栈区局部变量): " << &mainVar << endl;
return 0;
}（1）函数参数存储在栈区：
- 当调用 func(mainVar) 时，参数mainVar的值会被压入栈中，并作为 param传递给 func 函数。此时，param是栈区中的一个局部变量。
（2）局部变量存储在栈区：
- 在 func 函数内部，localVar是一个局部变量，它也存储在栈区中。这个变量会随着函数调用被压入栈中，并在函数返回时从栈中移除。
- 同样，在 main 函数中，mainVar是局部变量，存储在栈区。
（3）自动管理：
- func函数中的局部变量 localVar 和参数 param在函数返回后会自动从栈中销毁，内存被自动释放。
- mainVar 也是局部变量，当 main函数结束时，它的内存也会自动从栈中销毁。
### 输出示例（地址仅为示例）：
当函数调用时，局部变量和参数会被压入栈中，函数返回时栈上的这些变量会被自动销毁。
从输出中可以看到，栈中的局部变量和函数参数的内存地址是相邻的（栈通常是从高地址向低地址分配的），表明它们在栈区中分配。栈区的特点是遵循后进先出（LIFO）的原则，因此随着函数调用和返回，栈上的变量也会相应地分配和释放。
2. 堆区（Heap Segment）
- 特点：用于动态内存分配，程序员可以使用 new或 malloc 手动分配内存，并且需要使用 delete 或 free来释放。
- 分配方式：动态分配，由程序员控制内存的分配和释放。
- 优点：堆的空间非常大，可以根据需要动态调整分配的内存量。
- 缺点：分配和释放效率相对较慢，如果程序员忘记释放内存，会导致内存泄漏。频繁分配和释放可能会导致内存碎片。
- 典型使用：动态分配对象或数组。
#include <iostream>
#include <iomanip>
#include <assert.h>
using namespace std;
#include <iostream>
class MyClass {
public:
MyClass() {
cout << "创建对象" << endl;
}
~MyClass() {
cout << "销毁对象" << endl;
}
};
int main() {
// 在堆区动态分配一个整数
int* pInt = new int; //动态分配，存储在堆区
*pInt = 42;
cout << "堆区中的值: " << *pInt << endl;
cout << "堆区地址: " << pInt << endl;
// 在堆区动态分配一个对象
MyClass* pObj = new MyClass();// 动态分配对象，存储在堆区
// 动态分配一个数组
int* pArr = new int[5];// 在堆区分配一个数组
for (int i = 0; i < 5; ++i)
{
pArr[i] = i * 10;
cout << "pArr[" << i << "] = " << pArr[i] << endl;
}
// 释放堆区分配的内存
delete pInt;// 释放动态分配的整数
delete pObj;// 释放动态分配的对象
delete[] pArr;// 释放动态分配的数组
return 0;
}代码说明：
（1）动态分配一个整数：
- pInt本身的存储位置：pInt 是一个局部变量，存储在栈区。它是一个指针，存储着在堆区分配的那块内存的地址，这块地址是指向堆区的。
- new int 分配的内存的存储位置：new int 在堆区动态分配了一块 int 类型的内存，这块内存存储在堆区。该堆区内存存放了 42 这个值。通过 pInt 指针，可以访问并修改这块堆区内存的内容。
- 手动释放：使用 delete pInt; 来释放这块堆区的内存，否则会导致内存泄漏。
（2）动态分配一个对象：
- pObj 本身的存储位置：pObj 是一个局部指针变量，存储在栈区。它保存着 new MyClass() 在堆区动态分配的 MyClass 对象的地址，只是一个指向堆区内存的指针变量。
- new MyClass() 创建的对象的存储位置：new MyClass() 在堆区创建了一个 MyClass 类型的对象，该对象存储在堆区。pObj 指向这个在堆区创建的 MyClass 对象，程序员可以通过 pObj 访问和操作堆区中的该对象。
- 手动释放：使用 delete pObj; 来调用析构函数并释放对象占用的内存。
（3）动态分配一个数组：
- pArray本身的存储位置：pArray 是一个局部指针变量，存储在栈区。它保存着 new int[5] 分配的数组的首地址，即堆区中分配的数组的起始地址。
- new int[5]分配的数组的存储位置：new int[5] 在堆区动态分配了一个长度为 5 的 int 数组，该数组存储在堆区。数组的所有元素存储在堆区中，可以通过 pArray 来访问和修改这些元素。
- 手动释放：对于动态分配的数组，必须使用 delete[] pArray;来释放内存，使用普通的 delete 会导致未定义行为。
堆区的优点与缺点：
- 优点：堆区可以在运行时动态分配内存，灵活管理内存，适用于需要大量数据或者需要灵活调整大小的情况。
- 缺点：堆区的分配和释放需要程序员手动管理，容易出现内存泄漏或者内存释放错误，且分配和释放速度相对栈区较慢。
3. 全局/静态存储区（Data Segment）
- 特点：用于存储全局变量、静态变量（无论是否被static修饰）。全局变量和静态变量在程序运行时分配，并在程序结束时释放。
- 分为两部分：
- 已初始化数据段：存储已初始化的全局变量、静态变量。
- 未初始化数据段：存储未初始化的全局变量和静态变量。未初始化的全局/静态变量在程序开始时自动初始化为零。
- 分配方式：在程序启动时由系统分配，并在程序结束时释放。
- 典型使用：全局变量、静态局部变量。
#include <iostream>
using namespace std;
// 全局变量，存储在静态区
int globalVar = 100;
// 静态变量，存储在静态区
void staticFunc() {
static int staticVar = 10; // 静态变量，存储在静态区
staticVar++;
cout << "静态变量： " << staticVar << endl;
}
int main() {
// 调用函数，修改静态变量
staticFunc();
staticFunc();
return 0;
}- 全局变量 globalVar的存储位置：globalVar 是一个全局变量，存储在静态区的已初始化数据段。它在程序开始时被初始化为 100，并且直到程序结束时才被销毁。
- 静态变量 staticVar的存储位置：staticVar 是函数 staticFunc 中的静态变量，存储在静态区的已初始化数据段。与普通局部变量不同，静态变量的生命周期贯穿整个程序运行期间，即使函数结束后，静态变量的值也会保留。
- 常量 constVar 和字符串字面量：存储位置：constVar 和 "Hello, World!" 是常量，存储在静态区的常量区。常量在程序运行期间不会改变，且常量区内存是只读的。局部变量 localVar：存储位置：localVar 是局部变量，存储在栈区，它在 main 函数运行时创建，并在函数结束时被销毁。
4. 常量区
- 特点：用于存储常量数据（如字符串常量和const修饰的全局常量）。这部分内存是只读的，试图修改它将会导致运行时错误。
- 分配方式：由系统在程序启动时分配，并在程序结束时释放。
- 典型使用：字符串常量、const修饰的全局常量。
#include <iostream>
// const 全局常量，存储在常量区
const int constGlobalVar = 42;
int main() {
// 字符串字面量，存储在常量区
const char* str = "Hello, World!";
// const 局部常量，通常存储在栈区，但有时编译器也会将其优化到常量区
const int constLocalVar = 100;
// 输出全局常量和字符串字面量
cout << "全局常量：" << constGlobalVar << endl;
cout << "字符串常量： " << str << endl;
// 输出局部常量
cout << "局部常量：" << constLocalVar << endl;
return 0;
}- constGlobalVar：这是一个全局常量，存储在常量区，其值在程序运行期间不可修改。
- 字符串字面量 "Hello, World!"：这是一个字符串字面量，编译时存储在常量区，程序运行期间同样不可修改。
- constLocalVar：这是一个局部常量，通常情况下它存储在栈区，但在某些情况下，编译器可能会将它优化到常量区，特别是当它不被修改且是只读时，这取决于编译器。
5. 代码区
- 特点：用于存储程序的可执行代码，也称为文本段，程序的所有函数和方法的代码，包括 `main函数、全局函数、成员函数、静态成员函数等，都是在代码区内存储并执行的。都存储在代码区。该区域通常是只读的，防止程序在运行时修改其自身的代码。
- 分配方式：由系统在程序加载时分配，并在程序结束时释放，且不会动态增加或减少。
- 典型使用：存储编译好的指令和函数代码。
代码区的存储内容：
- 函数体的机器指令。
- 静态成员函数。
- 内联函数（在某些情况下，编译器也会将内联函数放在代码区中）。
#include <iostream>
// 函数存储在代码区
void functionInCodeSegment() {
std::cout << "This is a function stored in the code segment." << std::endl;
}
int main() {
// main 函数也存储在代码区
std::cout << "Hello, World! This is the code segment." << std::endl;
// 调用函数，函数体存储在代码区
functionInCodeSegment();
return 0;
}代码说明：
1. main 函数：main 函数的代码存储在代码区。当程序运行时，操作系统会加载并执行代码区中的指令。
2. functionInCodeSegment函数：同样地，这个函数的机器指令也存储在代码区中。每次调用该函数时，程序从代码区中读取并执行对应的指令。
内存布局：
+---------------------------+
| 代码区 (只读) |
|---------------------------|
| main 函数的指令 | --> 存储程序的可执行指令
| functionInCodeSegment 的指令|
+---------------------------+
| 数据区 (可读写) |
| 静态区、全局变量、常量区 | --> 全局变量、静态变量、常量等
+---------------------------+
| 堆区 |
| 动态分配的内存 (new/malloc)| --> 动态分配的数据
+---------------------------+
| 栈区 |
| 局部变量、函数调用信息 | --> 函数调用栈帧、局部变量
+---------------------------+
```
每个区域都有不同的管理方式和生命周期，合理管理这些内存区域对程序的性能和稳定性至关重要。
通过上面的学习，我们再来看一段代码，检验一下学习成果吧：
C c; // 全局变量，存储在静态区
void main()
{
A* pa = new A(); // 动态分配，存储在堆区
B b; // 栈上分配，存储在栈区
static D d; // 静态局部变量，存储在静态区
delete pa; // 回收堆区的内存
}
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = {1, 2, 3, 4};
char char2[] = "abcd";
char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof (int)*4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int)*4);
free (ptr1);
free (ptr3);
}以下对代码中的各类变量进行分析以确定其所在区域：
1. globalVar 是全局变量，存储在数据段（静态区）。
2. staticGlobalVar 也是全局静态变量，同样存储在数据段（静态区）。
3. staticVar 是静态局部变量，存储在数据段（静态区）。
4. localVar 是局部变量，存储在栈区。
5. num1 是局部数组，存储在栈区。
6. char2 是局部字符数组，存储在栈区。
7. pChar3 是指针变量，指向字符串常量，字符串常量存储在数据段（静态区），所以 pChar3 本身作为局部变量存储在栈区。
8. ptr1 、 ptr2 、 ptr3 是指针变量，作为局部变量存储在栈区，它们通过 malloc 、 calloc 、 realloc 分配的内存空间在堆区。