深入理解C++ 变量的存储位置

在C++中，变量的存储位置由其生命周期、作用域和定义方式决定，主要分布在4个核心内存区域：栈（Stack）、堆（Heap）、全局/静态存储区（.data/.bss段）、常量存储区（.rodata段）。下面结合代码逐步详解每个区域的特点及对应变量。

一、内存区域概览

先明确各区域的核心特性，后续结合代码具体分析：

二、代码实例与区域分析

下面通过一段包含多种变量的代码，逐个分析其存储位置：

// 1. 全局变量（未初始化）
int g_uninit;  

// 2. 全局变量（已初始化）
int g_init = 100;  

// 3. 全局const变量（常量）
const int g_const = 200;  

// 函数定义（用于演示参数和局部变量）
void test_func(int param) {  // param是函数参数
    // 4. 局部变量
    int local_var = 20;  

    // 5. 局部const变量
    const int local_const = 30;  

    // 6. 静态局部变量（已初始化）
    static int static_local_init = 40;  

    // 7. 静态局部变量（未初始化）
    static int static_local_uninit;  
}

int main() {
    // 8. 堆内存（动态分配）
    int* heap_ptr = new int(50);  

    // 9. 字符串常量
    const char* str = "hello world";  

    // 10. 局部对象（栈上）
    class MyClass { public: int x; } obj;  
    obj.x = 60;  

    // 11. 堆上的对象
    MyClass* heap_obj = new MyClass();  
    heap_obj->x = 70;  

    test_func(80);  // 调用函数，传入参数80

    // 释放堆内存（避免泄漏）
    delete heap_ptr;  
    delete heap_obj;  
    return 0;
}

1. 全局未初始化变量g_uninit

• 存储区域：全局/静态区的 .bss段（未初始化数据段）。
• 原因：定义在函数外部（全局作用域），且未初始化。.bss段专门存储未初始化的全局变量和静态变量，程序启动时会自动将其初始化为0。
• 生命周期：从程序启动到结束。

2. 全局已初始化变量g_init

• 存储区域：全局/静态区的 .data段（已初始化数据段）。
• 原因：全局作用域且已初始化（赋值100）。.data段存储已初始化的全局变量和静态变量，数据会直接保存在可执行文件中。
• 生命周期：整个程序运行期间。

3. 全局const变量g_const

• 存储区域：常量存储区（.rodata段）。
• 原因：const 修饰的全局变量是只读常量，编译器会将其放入只读的常量区，防止被修改（若强行修改会导致程序崩溃）。
• 注意：局部const变量（如local_const）不在常量区，见下文分析。

4. 函数参数param和局部变量local_var

• 存储区域：栈（Stack）。
• 原因：param 是函数参数，local_var 是函数内部定义的局部变量，它们的生命周期与函数调用绑定（函数进入时创建，退出时销毁），由编译器自动在栈上分配和释放。
• 特点：栈内存分配效率极高（仅需移动栈指针），但空间有限（通常几MB），递归过深或局部数组过大会导致栈溢出。

5. 局部const变量local_const

• 存储区域：栈（Stack）。
• 原因：虽然被const修饰，但它是局部变量（作用域限于test_func函数），生命周期随函数结束而销毁，因此存储在栈上。const仅在编译期限制修改，不改变其存储位置。
• 验证：若对局部const变量取地址（如&local_const），编译器会在栈上为其分配空间；若未取地址，可能被优化为立即数（不占内存）。

6. 静态局部变量static_local_init和static_local_uninit

• 存储区域：全局/静态区（static_local_init在.data段，static_local_uninit在.bss段）。
• 原因：static修饰的局部变量，虽然作用域限于函数内部，但生命周期是整个程序运行期间（与全局变量一致），因此存储在全局/静态区。
• 注意：静态变量只会初始化一次（即使函数多次调用），例如static_local_init的40仅在第一次调用test_func时赋值。

7. 堆内存指针heap_ptr及其指向的内容

• 存储区域：指针heap_ptr在栈上，其指向的int(50)在堆上。
• 原因：heap_ptr是main函数的局部变量（栈上）；new int(50)是动态分配，由程序员手动申请，存储在堆上，需通过delete手动释放（否则内存泄漏）。
• 堆的特点：空间大（远大于栈），分配/释放效率低（需查找空闲内存块），地址增长方向与栈相反（通常栈从高地址向低地址增长，堆从低地址向高地址增长）。

8. 字符串常量"hello world"

• 存储区域：常量存储区（.rodata段）。
• 原因：字符串常量是只读数据，编译器会将其放入常量区，多个相同字符串常量可能共享同一块内存（节省空间）。
• 注意：str是栈上的指针，指向常量区的字符串，若尝试修改（如str[0] = 'H'）会导致程序崩溃（访问只读内存）。

9. 局部对象obj及其成员x

• 存储区域：整个对象obj（包括成员x）在栈上。
• 原因：obj是main函数内定义的局部对象，未使用new，因此由编译器在栈上分配，随函数结束自动销毁，成员变量x作为对象的一部分自然也在栈上。

10. 堆上的对象heap_obj及其成员x

• 存储区域：指针heap_obj在栈上，其指向的对象（包括成员x）在堆上。
• 原因：new MyClass()动态分配对象，整个对象（包括成员x）存储在堆上，需通过delete释放，否则会泄漏堆内存。

三、关键区别总结

1. 栈 vs 堆：栈自动管理（速度快、空间小），堆手动管理（空间大、易泄漏）。
2. 全局/静态区 vs 常量区：前者可修改（如g_init），后者只读（如g_const、字符串常量）。
3. 局部静态变量：作用域局部，但生命周期全局，存储在全局/静态区。
4. 指针的存储：指针变量本身的位置由其定义方式决定（局部指针在栈，全局指针在全局区），而指针指向的内容位置由分配方式决定（new分配在堆，字符串常量在常量区）。

10道C++变量的hard难度多选题

1. 关于以下代码中变量的存储位置，说法正确的有（ ）

const int g_const = 10;  // 全局const变量
void func() {
    const int local_const = 20;  // 局部const变量
    static const int static_local_const = 30;  // 静态局部const变量
}

A. g_const 存储在常量存储区（.rodata段）
B. local_const 存储在常量存储区（.rodata段）
C. static_local_const 存储在全局/静态区（.data段）
D. 若未对local_const取地址，编译器可能将其优化为立即数（不占内存）

2. 对于以下代码，分析正确的有（ ）

char* str1 = "hello";  // 字符串常量
char str2[] = "hello";  // 局部数组初始化
char* str3 = new char[6];  // 动态分配数组
strcpy(str3, "hello");

A. "hello"在str1中存储于常量存储区，在str2中存储于栈
B. str1、str2、str3三个指针本身均存储在栈上
C. str3指向的内容存储在堆上，且内容可修改
D. 若str1和另一个char* str4 = "hello"同时存在，str1与str4可能指向同一块内存

3. 关于函数内变量的存储，以下说法正确的有（ ）

class A { int x; };
void test() {
    A a;  // 局部对象
    static A a_static;  // 静态局部对象
    A* a_heap = new A();  // 堆上的对象
}

A. 局部对象a的成员x存储在栈上
B. 静态局部对象a_static的成员x存储在全局/静态区
C. 指针a_heap存储在堆上，其指向的对象存储在栈上
D. 函数test多次调用时，a_static只会被初始化一次

4. 以下关于全局变量和静态全局变量的存储，正确的有（ ）

int g1;  // 全局未初始化变量
int g2 = 0;  // 全局初始化变量（值为0）
static int sg1;  // 静态全局未初始化变量
static int sg2 = 5;  // 静态全局初始化变量

A. g1和sg1均存储在全局/静态区的.bss段
B. g2存储在.data段（因显式初始化），sg1存储在.bss段
C. 静态全局变量与全局变量的存储区域相同，仅作用域不同（静态全局仅限当前文件）
D. .bss段的变量在程序启动时会被自动初始化为0，.data段的变量保留初始化值

5. 关于const变量的存储位置，下列说法错误的有（ ）

const int c1 = 100;  // 全局const
void func() {
    const int c2 = 200;  // 局部const
    const int* p1 = &c1;  // 指向全局const的指针
    int* const p2 = new int(300);  // const指针（指向堆）
}

A. c1和c2均存储在常量存储区
B. p1存储在栈上，其指向的内容存储在常量存储区
C. p2是const指针，其本身存储在堆上
D. p2指向的int(300)存储在堆上，且不可通过p2修改

6. 以下关于堆内存的描述，正确的有（ ）

int* func() {
    int* p = new int(5);  // 动态分配int
    return p;
}
int main() {
    int* ptr = func();
    delete ptr;
    ptr = nullptr;
    return 0;
}

A. 函数func中，指针p存储在栈上，其指向的int(5)存储在堆上
B. func返回后，p被销毁（栈回收），但堆上的int(5)仍存在（直到delete）
C. delete ptr后，堆上的内存被释放，但ptr本身（栈上）仍存在，直到main函数结束
D. 若未执行delete ptr，堆内存会泄漏，但程序结束后操作系统会自动回收

7. 关于类的静态成员变量，以下说法正确的有（ ）

class Test {
public:
    static int s1;  // 静态成员变量声明
    static const int s2 = 10;  // 静态const成员（类内初始化）
};
int Test::s1 = 20;  // 静态成员变量定义

A. Test::s1存储在全局/静态区的.data段
B. Test::s2存储在常量存储区（.rodata段）
C. 即使未实例化Test对象，s1和s2也已存在（生命周期为整个程序）
D. 静态成员变量属于类，而非对象，因此每个Test对象都包含s1的副本

8. 关于字符串存储的细节，正确的有（ ）

void func1() { const char* s1 = "abc"; }
void func2() { const char* s2 = "abc"; }
char* func3() { char s3[] = "abc"; return s3; }

A. s1和s2指向的"abc"可能存储在常量区的同一地址（字符串常量共享）
B. func3中s3是局部数组，"abc"作为初始化数据存储在栈上
C. func3返回s3后，其指向的栈内存已被释放，使用该指针会导致未定义行为
D. 若修改s3[0] = 'x'是合法的（栈内存可修改），而修改s1[0] = 'x'会崩溃（常量区只读）

9. 以下关于递归函数中局部变量的存储，正确的有（ ）

int fib(int n) {
    int temp = n;  // 局部变量
    if (n <= 1) return 1;
    return fib(n-1) + fib(n-2);
}

A. 每次调用fib函数时，temp都会在栈上分配新的内存空间
B. 不同递归层级的temp存储在栈上的不同位置，互不干扰
C. 若n过大（如10000），可能因栈空间不足导致栈溢出
D. 递归结束后，各层级的temp会随函数返回依次被栈自动释放

10. 综合分析以下代码中变量的存储，正确的有（ ）

int g_var;  // 全局未初始化
static int sg_var = 5;  // 静态全局初始化
int main() {
    static int s_var;  // 静态局部未初始化
    int* h_var = new int(10);  // 堆变量
    const char* str = "test";  // 字符串常量
    return 0;
}

A. g_var和s_var均存储在全局/静态区的.bss段
B. sg_var存储在全局/静态区的.data段
C. h_var存储在栈上，其指向的int(10)存储在堆上
D. str存储在栈上，其指向的"test"存储在常量区

答案与解析

1. 答案：ACD

解析：

• A正确：全局const变量g_const存储在常量存储区（只读）。
• B错误：局部const变量local_const是函数内局部变量，存储在栈上（const仅限制编译期修改，不改变存储位置）。
• C正确：静态局部const变量static_local_const生命周期为全局，存储在全局/静态区（因初始化值为30，在.data段）。
• D正确：若未对local_const取地址，编译器可能将其优化为立即数（直接嵌入指令，不占内存）。

2. 答案：ACD

解析：

• A正确：str1指向的"hello"是字符串常量（常量区）；str2是局部数组，"hello"作为初始化数据复制到栈上的数组中。
• B错误：str2是数组名（非指针），本身代表栈上数组的首地址，并非指针变量（指针变量需显式声明为char*）。
• C正确：str3是局部指针（栈上），指向堆上动态分配的数组，堆内存可修改（strcpy合法）。
• D正确：常量区的相同字符串常量可能共享内存（编译器优化），故str1与str4可能指向同一地址。

3. 答案：ABD

解析：

• A正确：局部对象a在栈上，其成员x作为对象的一部分也在栈上。
• B正确：静态局部对象a_static存储在全局/静态区，其成员x自然也在该区域。
• C错误：a_heap是局部指针（栈上），指向堆上的对象（堆上）。
• D正确：静态局部变量仅在第一次函数调用时初始化，后续调用不再初始化。

4. 答案：ABCD

解析：

• A正确：未初始化的全局变量（g1）和静态全局变量（sg1）均在.bss段。
• B正确：g2显式初始化为0（仍算初始化），在.data段；sg1未初始化，在.bss段。
• C正确：静态全局变量与全局变量存储区域相同（全局/静态区），区别是静态全局仅限当前文件访问（作用域限制）。
• D正确：.bss段变量由系统自动初始化为0，.data段变量保留显式初始化值。

5. 答案：ACD

解析：

• A错误：c1（全局const）在常量区，c2（局部const）在栈上，二者存储区域不同。
• B正确：p1是局部指针（栈上），指向全局const变量c1（常量区）。
• C错误：p2是局部const指针（指针本身不可修改），存储在栈上（非堆）。
• D错误：p2指向堆上的int(300)，p2是“指针本身const”（int* const），不限制指向内容的修改（可通过*p2 = 400修改）。

6. 答案：ABCD

解析：

• A正确：p是func的局部指针（栈上），指向堆上的int(5)。
• B正确：func返回后，栈上的p被销毁，但堆内存未释放（直到main中delete ptr）。
• C正确：delete ptr释放堆内存，但ptr本身是main的局部变量（栈上），直到main结束才销毁。
• D正确：内存泄漏指程序未手动释放，但程序结束后操作系统会回收所有进程资源（包括未释放的堆内存）。

7. 答案：ABC

解析：

• A正确：Test::s1是静态成员变量，显式初始化为20，存储在全局/静态区的.data段。
• B正确：静态const成员Test::s2在类内初始化，属于全局常量，存储在常量区。
• C正确：静态成员变量独立于对象存在，程序启动时已分配内存，无需实例化对象。
• D错误：静态成员变量属于类，所有对象共享同一份，而非每个对象有副本。

8. 答案：ABCD

解析：

• A正确：常量区的相同字符串常量可能被编译器优化为共享内存，故s1和s2可能指向同一地址。
• B正确：s3是局部数组，"abc"作为初始化数据被复制到栈上的数组中（非常量区）。
• C正确：func3返回局部数组的地址，函数结束后栈内存释放，使用该指针会访问无效内存（未定义行为）。
• D正确：s3在栈上（可修改），s1指向常量区（只读，修改会崩溃）。

9. 答案：ABCD

解析：

• A正确：每次函数调用都会在栈上为局部变量temp分配新空间。
• B正确：不同递归层级的temp是独立变量，存储在栈的不同位置，值互不影响。
• C正确：递归层级过深会导致栈上分配的局部变量过多，超出栈空间限制（栈溢出）。
• D正确：栈遵循“先进后出”，递归返回时，外层函数的temp会在内存函数释放后依次释放。

10. 答案：ABCD

解析：

• A正确：g_var（全局未初始化）和s_var（静态局部未初始化）均在全局/静态区的.bss段。
• B正确：sg_var是静态全局变量，显式初始化为5，在.data段。
• C正确：h_var是main的局部指针（栈上），指向堆上动态分配的int(10)。
• D正确：str是局部指针（栈上），指向常量区的字符串"test"。

实践题目

#include <iostream>
const int g_const = 10;          // 常量区
int g_var = 20;                  // .data段
static int s_var = 30;           // .data段
char* p_str = "Hello";           // p_str在.data段，"Hello"在常量区
void memory_layout_demo() {
    static int local_s_var = 40; // .data段
    int local_var = 50;          // 栈
    const int local_const = 60;  // 栈

    int* heap_var = new int(70); // heap_var在栈，指向堆内存
    char arr[] = "World";        // 栈（数组在栈上分配）

    std::cout << "g_const: " << &g_const << std::endl;
    std::cout << "g_var: " << &g_var << std::endl;
    std::cout << "s_var: " << &s_var << std::endl;
    std::cout << "p_str: " << &p_str << " -> " << (void*)p_str << std::endl;
    std::cout << "local_s_var: " << &local_s_var << std::endl;
    std::cout << "local_var: " << &local_var << std::endl;
    std::cout << "local_const: " << &local_const << std::endl;
    std::cout << "heap_var: " << &heap_var << " -> " << heap_var << std::endl;
    std::cout << "arr: " << &arr << std::endl;

    delete heap_var;
}
int main() {
    memory_layout_demo();
    return 0;
}
// 编译运行: g++ -std=c++11 memory_layout.cpp -o memory_layout

参考答案：

g_const：存储在常量区，因为是const全局常量

g_var：存储在.data段，已初始化的全局变量

s_var：存储在.data段，静态全局变量

p_str：指针本身在.data段，指向的字符串"Hello"在常量区

local_s_var：存储在.data段，静态局部变量

local_var：存储在栈，普通局部变量

local_const：存储在栈，const局部变量

heap_var：指针本身在栈，指向的内存地址在堆

arr：存储在栈，数组在栈上分配空间

到此这篇关于深入理解C++ 变量的存储位置的文章就介绍到这了,更多相关C++ 变量的存储位置内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

最新评论