一.C/C++内存分布

首先我了解一下C/C++中程序内存区域的划分

以下就是大致的图形

那么各区域是用来干嘛的呢？

1. 代码区（Text Segment）

• 作用：存放编译后的机器指令（即程序的执行代码）。

• 特点：

  • 只读（防止程序被意外修改）。

  • 程序启动时由操作系统加载到内存。

  • 多个运行实例共享同一份代码区（节省内存）。

2. 常量区（Constant Data Segment）

• 作用：存放常量数据（如字符串常量、const全局变量）。

• 示例：

  const int MAX = 100;        // 全局常量（可能在常量区）
  char* str = "Hello";        // 字符串"Hello"存储在常量区

• 特点：

  • 只读，修改会导致段错误（如尝试修改str[0] = 'h'会崩溃）。

  • 生命周期与程序一致。

3. 全局/静态存储区（Global/Static Segment）

分为两部分：

• 数据段（Data Segment）：存放已初始化的全局变量和静态变量。

  int global = 5;             // 已初始化的全局变量（数据段）
  static int s_var = 10;      // 已初始化的静态变量（数据段）

• BSS段（Block Started by Symbol）：存放未初始化的全局变量和静态变量。

  int uninit_global;          // 未初始化的全局变量（BSS段，默认值为0）
  static int uninit_static;   // 未初始化的静态变量（BSS段，默认值为0）

• 特点：

  • 程序启动时分配，结束时释放。

  • BSS段变量默认初始化为0（或NULL）。

4. 堆区（Heap）

• 作用：用于动态内存分配（如malloc/new）。

• 示例：

  int* arr = (int*)malloc(10 * sizeof(int));  // 堆内存分配（C）
  int* ptr = new int[10];                     // 堆内存分配（C++）

• 特点：

  • 手动申请和释放（free/delete），忘记释放会导致内存泄漏。

  • 空间较大，但分配和释放效率较低。

  • 内存从低地址向高地址增长。

5. 栈区（Stack）

• 作用：存放局部变量、函数参数、返回地址等。

• 示例：

  void func() {int a = 10;            // 局部变量（栈区）char str[] = "Stack";  // 字符数组（栈区）
  }

• 特点：

  • 由编译器自动分配和释放（函数结束时栈帧弹出）。

  • 空间有限（默认约几MB），过度使用会导致栈溢出（如递归过深）。

  • 内存从高地址向低地址增长。

例题导入：

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";
const 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. 选择题：
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里？____
staticGlobalVar在哪里？____
staticVar在哪里？____
localVar在哪里？____
num1 在哪里？____
char2在哪里？____
*char2在哪里？___
pChar3在哪里？____
*pChar3在哪里？____
ptr1在哪里？____
*ptr1在哪里？____

由上述所学：

二. C语言中动态内存管理方式：malloc/calloc/realloc/free

#include <stdio.h>
#include <stdlib.h>int main() {// 使用 calloc 分配并初始化int* arr = (int*)calloc(5, sizeof(int));if (arr == NULL) exit(1);// 修改数据for (int i = 0; i < 5; i++) arr[i] = i;// 使用 realloc 扩展内存int* new_arr = (int*)realloc(arr, 10 * sizeof(int));if (new_arr == NULL) {free(arr); // 释放原内存exit(1);}arr = new_arr;// 使用 malloc 分配额外内存int* temp = (int*)malloc(3 * sizeof(int));if (temp == NULL) {free(arr);exit(1);}// 释放所有内存free(arr);free(temp);return 0;
}

void Test()
{// 动态申请一个int类型的空间int* ptr4 = new int;// 动态申请一个int类型的空间并初始化为10int* ptr5 = new int(10);// 动态申请10个int类型的空间int* ptr6 = new int[3];delete ptr4;delete ptr5;delete[] ptr6;
}

class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};int main()
{// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间
还会调用构造函数和析构函数A* p1 = (A*)malloc(sizeof(A));A* p2 = new A(1);free(p1);delete p2;// 内置类型是几乎是一样的int* p3 = (int*)malloc(sizeof(int)); // Cint* p4 = new int;free(p3);delete p4;A* p5 = (A*)malloc(sizeof(A)*10);A* p6 = new A[10];free(p5);delete[] p6;return 0;
}

//当A有默认构造的时候
A* p1=new A(1);
A* p2=new A[3]{1,2,3}
//隐式类型转换+编译器优化=直接构造

int* p = new int[n];

A* p=new A[10];
delete[] p;

A* p=new A[10];
delete p;

int* p=new int[10];
delete p;