C语言程序的内存管理是理解程序运行机制的关键。东巴文（db-w.cn） 将带你深入理解C语言的内存分区模型,掌握程序在内存中的布局。
💡 东巴文观点：理解内存分区模型是成为高级C程序员的必经之路,它帮助你理解变量的生命周期、作用域和程序的运行机制。
#include <stdio.h>
#include <stdlib.h>
// 全局变量 - 全局区
int globalInit = 100; // 已初始化全局变量
int globalUninit; // 未初始化全局变量
// 静态全局变量 - 全局区
static int staticGlobal = 200;
// 常量 - 常量区
const int constGlobal = 300;
void memoryLayoutDemo() {
printf("=== 东巴文内存分区模型详解 ===\n\n");
// 局部变量 - 栈区
int localVar = 10;
// 静态局部变量 - 全局区
static int staticLocal = 20;
// 动态分配 - 堆区
int *heapVar = (int *)malloc(sizeof(int));
*heapVar = 30;
// 常量 - 常量区
const int constLocal = 40;
printf("栈区（Stack）：\n");
printf(" localVar地址：%p\n", &localVar);
printf(" 特点：自动管理,向下生长\n\n");
printf("堆区（Heap）：\n");
printf(" heapVar地址：%p\n", heapVar);
printf(" 特点：手动管理,向上生长\n\n");
printf("全局区（Global）：\n");
printf(" globalInit地址：%p\n", &globalInit);
printf(" globalUninit地址：%p\n", &globalUninit);
printf(" staticGlobal地址：%p\n", &staticGlobal);
printf(" staticLocal地址：%p\n", &staticLocal);
printf(" 特点：程序启动时分配,程序结束时释放\n\n");
printf("常量区（Constant）：\n");
printf(" constGlobal地址：%p\n", &constGlobal);
printf(" constLocal地址：%p\n", &constLocal);
printf(" 特点：只读,不可修改\n\n");
printf("代码区（Code）：\n");
printf(" memoryLayoutDemo函数地址：%p\n", memoryLayoutDemo);
printf(" 特点：只读,存储程序代码\n");
free(heapVar);
}
int main() {
memoryLayoutDemo();
return 0;
}
东巴文内存分区表：
| 区域 | 英文名 | 存储内容 | 管理方式 | 生长方向 | 生命周期 |
|---|---|---|---|---|---|
| 栈区 | Stack | 局部变量、函数参数、返回地址 | 自动管理 | 向下生长 | 函数调用期间 |
| 堆区 | Heap | 动态分配的内存 | 手动管理 | 向上生长 | 程序员控制 |
| 全局区 | Global/Static | 全局变量、静态变量 | 系统管理 | - | 程序运行期间 |
| 常量区 | Constant | 常量、字符串字面量 | 系统管理 | - | 程序运行期间 |
| 代码区 | Code/Text | 程序代码、指令 | 系统管理 | - | 程序运行期间 |
#include <stdio.h>
void stackDemo() {
printf("=== 东巴文栈区详解 ===\n\n");
int a = 10;
int b = 20;
int c = 30;
printf("栈区变量地址（向下生长）：\n");
printf(" &a = %p\n", &a);
printf(" &b = %p\n", &b);
printf(" &c = %p\n", &c);
printf("\n栈区特点：\n");
printf(" 1. 自动分配和释放\n");
printf(" 2. 空间有限（通常几MB）\n");
printf(" 3. 后进先出（LIFO）\n");
printf(" 4. 生长方向：从高地址向低地址\n");
printf(" 5. 存储局部变量、函数参数、返回地址\n");
}
void stackOverflow() {
// ❌ 错误：可能导致栈溢出
// int largeArray[10000000]; // 栈空间不足
// ✅ 正确：使用堆区
int *largeArray = (int *)malloc(10000000 * sizeof(int));
// 使用...
free(largeArray);
}
int main() {
stackDemo();
return 0;
}
#include <stdio.h>
void funcC() {
int c = 30;
printf("funcC: c = %d, &c = %p\n", c, &c);
}
void funcB() {
int b = 20;
printf("funcB: b = %d, &b = %p\n", b, &b);
funcC();
printf("funcB: 返回\n");
}
void funcA() {
int a = 10;
printf("funcA: a = %d, &a = %p\n", a, &a);
funcB();
printf("funcA: 返回\n");
}
int main() {
printf("=== 东巴文函数调用栈 ===\n\n");
printf("调用顺序：main -> funcA -> funcB -> funcC\n\n");
funcA();
printf("\n栈帧结构：\n");
printf(" funcC的栈帧\n");
printf(" funcB的栈帧\n");
printf(" funcA的栈帧\n");
printf(" main的栈帧\n");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main() {
printf("=== 东巴文堆区详解 ===\n\n");
int *ptr1 = (int *)malloc(sizeof(int));
int *ptr2 = (int *)malloc(sizeof(int));
int *ptr3 = (int *)malloc(sizeof(int));
printf("堆区变量地址（向上生长）：\n");
printf(" ptr1 = %p\n", ptr1);
printf(" ptr2 = %p\n", ptr2);
printf(" ptr3 = %p\n", ptr3);
printf("\n堆区特点：\n");
printf(" 1. 手动分配和释放\n");
printf(" 2. 空间较大（受限于物理内存）\n");
printf(" 3. 灵活控制\n");
printf(" 4. 生长方向：从低地址向高地址\n");
printf(" 5. 存储动态分配的内存\n");
// 释放内存
free(ptr1);
free(ptr2);
free(ptr3);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
void heapVsStack() {
printf("=== 东巴文堆与栈的区别 ===\n\n");
// 栈区变量
int stackVar = 100;
// 堆区变量
int *heapVar = (int *)malloc(sizeof(int));
*heapVar = 200;
printf("栈区变量：\n");
printf(" 地址：%p\n", &stackVar);
printf(" 值：%d\n", stackVar);
printf(" 管理：自动\n");
printf(" 生命周期：函数调用期间\n\n");
printf("堆区变量：\n");
printf(" 地址：%p\n", heapVar);
printf(" 值：%d\n", *heapVar);
printf(" 管理：手动\n");
printf(" 生命周期：程序员控制\n");
free(heapVar);
}
int main() {
heapVsStack();
return 0;
}
东巴文堆栈对比表：
| 特性 | 栈区 | 堆区 |
|---|---|---|
| 管理方式 | 自动管理 | 手动管理 |
| 空间大小 | 较小（几MB） | 较大（受限于物理内存） |
| 生长方向 | 向下生长 | 向上生长 |
| 分配效率 | 快 | 慢 |
| 碎片问题 | 无 | 有 |
| 生命周期 | 函数调用期间 | 程序员控制 |
| 适用场景 | 局部变量、函数调用 | 大数据、动态数据结构 |
#include <stdio.h>
// 已初始化全局变量
int globalInit = 100;
// 未初始化全局变量
int globalUninit;
void globalDemo() {
printf("=== 东巴文全局变量 ===\n\n");
printf("已初始化全局变量：\n");
printf(" globalInit = %d\n", globalInit);
printf(" &globalInit = %p\n", &globalInit);
printf("\n未初始化全局变量：\n");
printf(" globalUninit = %d（默认初始化为0）\n", globalUninit);
printf(" &globalUninit = %p\n", &globalUninit);
printf("\n全局变量特点：\n");
printf(" 1. 程序启动时分配\n");
printf(" 2. 程序结束时释放\n");
printf(" 3. 默认初始化为0\n");
printf(" 4. 全局可见\n");
}
int main() {
globalDemo();
return 0;
}
#include <stdio.h>
// 静态全局变量
static int staticGlobal = 200;
void staticDemo() {
printf("=== 东巴文静态变量 ===\n\n");
// 静态局部变量
static int staticLocal = 0;
staticLocal++;
printf("静态局部变量：\n");
printf(" staticLocal = %d\n", staticLocal);
printf(" &staticLocal = %p\n", &staticLocal);
printf("\n静态全局变量：\n");
printf(" staticGlobal = %d\n", staticGlobal);
printf(" &staticGlobal = %p\n", &staticGlobal);
printf("\n静态变量特点：\n");
printf(" 1. 程序启动时分配\n");
printf(" 2. 程序结束时释放\n");
printf(" 3. 默认初始化为0\n");
printf(" 4. 静态局部变量：作用域局部,生命周期全局\n");
printf(" 5. 静态全局变量：作用域文件,生命周期全局\n");
}
int main() {
staticDemo();
staticDemo();
staticDemo();
return 0;
}
#include <stdio.h>
// 全局常量
const int constGlobal = 100;
void constantDemo() {
printf("=== 东巴文常量区 ===\n\n");
// 局部常量
const int constLocal = 200;
// 字符串字面量
char *str = "Hello, 东巴文";
printf("全局常量：\n");
printf(" constGlobal = %d\n", constGlobal);
printf(" &constGlobal = %p\n", &constGlobal);
printf("\n局部常量：\n");
printf(" constLocal = %d\n", constLocal);
printf(" &constLocal = %p\n", &constLocal);
printf("\n字符串字面量：\n");
printf(" str = %s\n", str);
printf(" str地址 = %p\n", str);
printf("\n常量区特点：\n");
printf(" 1. 只读,不可修改\n");
printf(" 2. 程序启动时分配\n");
printf(" 3. 程序结束时释放\n");
printf(" 4. 存储常量和字符串字面量\n");
// ❌ 错误：尝试修改常量
// constGlobal = 200; // 编译错误
// str[0] = 'h'; // 运行时错误
}
int main() {
constantDemo();
return 0;
}
#include <stdio.h>
void function1() {
printf("function1\n");
}
void function2() {
printf("function2\n");
}
int main() {
printf("=== 东巴文代码区 ===\n\n");
printf("函数地址：\n");
printf(" main = %p\n", main);
printf(" function1 = %p\n", function1);
printf(" function2 = %p\n", function2);
printf("\n代码区特点：\n");
printf(" 1. 只读,防止程序被意外修改\n");
printf(" 2. 程序启动时加载\n");
printf(" 3. 程序结束时释放\n");
printf(" 4. 存储程序代码和指令\n");
printf(" 5. 共享,多个进程可共享同一代码\n");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 全局变量
int globalVar = 100;
static int staticGlobalVar = 200;
const int constGlobalVar = 300;
void memoryAllocationDemo() {
printf("=== 东巴文内存分配综合示例 ===\n\n");
// 栈区
int stackVar = 10;
int stackArray[5] = {1, 2, 3, 4, 5};
// 堆区
int *heapVar = (int *)malloc(sizeof(int));
int *heapArray = (int *)malloc(5 * sizeof(int));
// 静态局部变量
static int staticLocalVar = 20;
// 常量
const int constLocalVar = 30;
char *stringLiteral = "东巴文";
printf("栈区：\n");
printf(" stackVar地址：%p\n", &stackVar);
printf(" stackArray地址：%p\n", stackArray);
printf("\n堆区：\n");
printf(" heapVar地址：%p\n", heapVar);
printf(" heapArray地址：%p\n", heapArray);
printf("\n全局区：\n");
printf(" globalVar地址：%p\n", &globalVar);
printf(" staticGlobalVar地址：%p\n", &staticGlobalVar);
printf(" staticLocalVar地址：%p\n", &staticLocalVar);
printf("\n常量区：\n");
printf(" constGlobalVar地址：%p\n", &constGlobalVar);
printf(" constLocalVar地址：%p\n", &constLocalVar);
printf(" stringLiteral地址：%p\n", stringLiteral);
printf("\n代码区：\n");
printf(" main函数地址：%p\n", main);
printf(" memoryAllocationDemo函数地址：%p\n", memoryAllocationDemo);
// 释放堆内存
free(heapVar);
free(heapArray);
}
int main() {
memoryAllocationDemo();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
void bestPractice1() {
printf("=== 东巴文合理选择存储区域 ===\n\n");
// ✅ 小数据、临时数据：使用栈区
int temp = 100;
printf("临时变量（栈区）：temp = %d\n", temp);
// ✅ 大数据、动态数据：使用堆区
int *largeData = (int *)malloc(10000 * sizeof(int));
printf("大数据（堆区）：已分配\n");
free(largeData);
// ✅ 全局共享数据：使用全局区
// globalVar = 200;
// ✅ 常量数据：使用常量区
const int max = 1000;
printf("常量（常量区）：max = %d\n", max);
}
int main() {
bestPractice1();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
void avoidStackOverflow() {
printf("=== 东巴文避免栈溢出 ===\n\n");
// ❌ 错误：大数组放在栈区
// int largeArray[10000000]; // 可能导致栈溢出
// ✅ 正确：大数组放在堆区
int *largeArray = (int *)malloc(10000000 * sizeof(int));
if (largeArray != NULL) {
printf("大数组已分配在堆区\n");
free(largeArray);
}
}
int main() {
avoidStackOverflow();
return 0;
}
#include <stdio.h>
void variableLifetime() {
printf("=== 东巴文理解变量生命周期 ===\n\n");
// 局部变量：函数调用期间
int localVar = 10;
printf("局部变量：localVar = %d\n", localVar);
// 静态局部变量：程序运行期间
static int staticLocalVar = 0;
staticLocalVar++;
printf("静态局部变量：staticLocalVar = %d\n", staticLocalVar);
// 动态分配：手动控制
int *dynamicVar = (int *)malloc(sizeof(int));
*dynamicVar = 20;
printf("动态分配：*dynamicVar = %d\n", *dynamicVar);
free(dynamicVar);
}
int main() {
printf("第一次调用：\n");
variableLifetime();
printf("\n第二次调用：\n");
variableLifetime();
return 0;
}
完成本章学习后,请确认：
掌握内存分区模型后,你可以继续学习：
如果遇到问题,欢迎访问 东巴文（db-w.cn） 获取帮助！
东巴文（db-w.cn） - 让编程学习更简单
🎯 东巴文内存分区提示：理解内存分区模型是成为高级C程序员的必经之路。在 db-w.cn,我们会通过大量实例帮你掌握内存分区模型！