C\C++5(内存管理)

🚀C/C++ 内存管理通关手册 | 能秒懂的核心知识点
（适合初学者的学习 & 复习指南，从基础到面试考点全拆解）
📚目录
一.🍬【开胃小菜】先搞懂内存长啥样？------C/C++ 程序内存分布
内存区域 "分区表"：栈 / 堆 / 数据段 / 代码段都是干啥的？
经典例题：变量住哪？新手也能秒判断
踩坑必看：sizeof 和 strlen 的 "爱恨情仇"（附计算题）
二. 🛠️【C 语言基本功】手动搬砖 ------ 动态内存管理
malloc/calloc/realloc/free：四大函数怎么用？
必避坑：三大申请函数的区别（一张表讲清）
保命规范：用错就崩的核心规则（附代码示例）
面试小加餐：malloc 底层咋干活的？（新手版简化解释）
三.🚀【C++ 升级款】智能搬砖 ------new/delete 登场
内置类型：new/delete 比 malloc 香在哪？（语法更简单！）
自定义类型：new/delete 的 "独门绝技"（构造 / 析构函数）
新手红线：new [] 和 delete [] 必须成对！（错了就翻车）
四.🔍【底层揭秘】new/delete 的 "幕后黑手"------operator new/delete
新手能懂的底层逻辑：这俩函数不是重载，是 "工具人"
源码简化版：不用懂全，看个大概就够
关键提醒：new 申请失败不返回 NULL，会 "抛异常"！
五.🧩【高级玩法】定位 new------ 内存池的 "好搭档"
新手视角：定位 new 是啥？（人话版解释）
实操示例：手把手教你用定位 new 初始化对象
核心注意：用完必须手动调析构！（最容易忘）
六.❌【避坑指南】内存泄漏 ------ "头号敌人"
啥是内存泄漏？（新手能懂的大白话）
为啥可怕？（短期程序没事，长期程序必崩）
怎么检测？（VS/Linux 新手友好工具）
怎么避免？（新手能落地的 5 个小技巧）
七.📝【面试必背】malloc/free vs new/delete（新手版对比）
共同点：都是从堆上 "借内存"，都要手动还
不同点：一张表搞定（新手能记住的核心区别）
八.🎯【总结】记忆口诀 + 核心考点回顾
内存分布口诀：栈下堆上，静态全局在数据段
内存管理核心：申请要匹配，释放要及时

一、🍬【开胃小菜】先搞懂内存长啥样？------C/C++ 程序内存分布

学内存管理第一步不是记函数，而是搞清楚 "内存到底咋分的"------ 就像你家房子分客厅、卧室、厨房，不同区域放不同东西，内存也一样，不同数据有不同 "住处"。

1. 内存区域 "分区表"：能懂的通俗解释

2. 经典例题：变量住哪？

// 全局变量 → 数据段
int globalVar = 1;
// static全局变量 → 数据段
static int staticGlobalVar = 1;

void Test()
{
    // static局部变量 → 数据段
    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);
}

小技巧：

1.看 "生命周期" ：程序运行全程在的（全局、static）→ 数据段；

2.看 "是否手动申请" ：new/malloc 出来的→ 堆（指向的内容）；

3.剩下的局部变量、函数参数→ 栈

3. 踩坑必看：sizeof 和 strlen 的 "爱恨情仇"（附计算题）

最容易搞混这俩，尤其是笔试必考，用 "人话 + 例子" 讲清：

// 新手口算：int占4字节，10个元素 → 4*10=40
sizeof(num1) = 40;
// 字符串数组包含'a/b/c/d/\0' → 5个字符，每个1字节 → 5
sizeof(char2) = 5;
// strlen不算'\0' → 4
strlen(char2) = 4;
// 指针大小：32位系统4字节，64位8字节（新手记死：指针大小只看系统位数）
sizeof(pChar3) = 8; // 64位系统
// 字符串有效长度 → 4
strlen(pChar3) = 4;

避坑提醒：

别用 strlen 算非字符串（比如 int 数组），会崩！

字符串数组（char2）和字符串常量（pChar3 指向的）不一样：前者在栈能改，后者在代码段不能改！

二、🛠️【C 语言基本功】手动搬砖 ------ 动态内存管理
C 语言没有自动内存管理，堆内存全靠 "手动搬砖"------malloc/calloc/realloc/free 这四个函数，新手要先会用，再记规则。

1. 四大函数怎么用？（版代码）

#include <stdio.h>
#include <stdlib.h> // 必须包含这个头文件！

int main()
{
    // 1. malloc：申请空间，不初始化（里面是随机值）
    int* p1 = (int*)malloc(sizeof(int));
    if (p1 == NULL) { // 新手必加：判空！申请失败会返回NULL
        printf("malloc失败！\n");
        return -1;
    }
    *p1 = 10; // 手动赋值
    free(p1); // 释放！用完必须放，不然内存泄漏
    p1 = NULL; // 新手好习惯：释放后置NULL，避免野指针

    // 2. calloc：申请+初始化全0（新手超爱这个，不用手动清脏数据）
    int* p2 = (int*)calloc(4, sizeof(int)); // 4个int，全0
    if (p2 == NULL) {
        printf("calloc失败！\n");
        return -1;
    }
    // 3. realloc：调整空间大小（新手慎用，扩容失败会返回NULL）
    int* p3 = (int*)realloc(p2, sizeof(int)*10); // 扩容到10个int
    if (p3 == NULL) { // 扩容失败，原p2还能用，别丢了！
        printf("realloc失败！\n");
        free(p2); // 原空间要释放
        p2 = NULL;
        return -1;
    }
    free(p3); // 扩容后只释放新指针，原p2失效了！
    p3 = NULL;

    return 0;
}

2. 必避坑：三大申请函数的区别（一张表讲清 )

3. 保命规范：用错就崩的核心规则（记死）

1.申请后必须判空 ：malloc/calloc/realloc 都可能失败（比如内存满了），返回 NULL，直接用会崩；

2.释放要匹配 ：malloc/calloc/realloc 申请的，只能用 free 释放，且只能放一次（放两次会崩）；

3.释放后置 NULL ：避免野指针（指向已释放的内存，最容易犯这个错）；

4.别越界：比如申请 4 个 int，别访问第 5 个，会踩内存（调试时多打印下标）。

4. 面试小加餐：malloc 底层咋干活的？（简洁解释）

malloc 不是每次都向系统要内存，而是先 "囤" 一块大内存（叫内存池），你要小内存时，直接从池子里抠，这样更快；如果要的内存太大（比如超过 128K），才直接找系统要；释放时，malloc 会把空闲的小块合并，避免内存碎片（就像拼图，碎了拼不回去，占地方）

三、🚀【C++ 升级款】智能搬砖 ------new/delete 登场

C++ 保留了 C 语言的 malloc/free，但给准备了更友好的 new/delete------ 语法更简单，还能自动调用构造 / 析构函数（对自定义类型超友好）。

1. 内置类型：new/delete 比 malloc 香在哪？（友好版）

#include <iostream>
using namespace std;

int main()
{
    // 1. 申请单个int，不初始化
    int* ptr4 = new int;
    // 2. 申请+初始化（新手超爱：不用手动赋值）
    int* ptr5 = new int(10); // 直接初始化为10，比malloc+赋值省事！
    // 3. 申请数组
    int* ptr6 = new int[10]; // 10个int，未初始化

    // 释放：新手记死------单个用delete，数组用delete[]
    delete ptr4;
    delete ptr5;
    delete[] ptr6; // 少写[]会崩！新手别漏

    // 新手对比：new vs malloc
    // malloc要强转，new不用：int* p = (int*)malloc(sizeof(int));
    // new失败抛异常，不用判空；malloc要判空
    return 0;
}

2. 自定义类型：new/delete 的 "独门绝技"（必懂）
   新手学 C++，一定要懂 new/delete 对自定义类型的特殊处理 ------ 这是和 malloc/free 最大的区别！

#include <iostream>
using namespace std;

// 自定义类（新手先记：构造函数初始化，析构函数清理）
class A
{
public:
    // 构造函数：创建对象时自动调
    A(int a = 0) : _a(a)
    {
        cout << "A()：创建对象，_a=" << _a << endl;
    }
    // 析构函数：销毁对象时自动调
    ~A()
    {
        cout << "~A()：销毁对象，_a=" << _a << endl;
    }
private:
    int _a;
};

int main()
{
    // 1. malloc：只给空间，不调构造函数（对象没初始化，不能用！）
    A* p1 = (A*)malloc(sizeof(A));
    free(p1); // 只释放空间，不调析构函数

    // 2. new：先给空间，再调构造函数（对象完整，能正常用）
    A* p2 = new A(10); // 调构造函数，_a=10
    delete p2; // 先调析构函数，再释放空间

    // 3. 数组版：new[]调N次构造，delete[]调N次析构
    A* p3 = new A[5]; // 调5次构造函数
    delete[] p3; // 调5次析构函数（少写[]会只调1次，内存泄漏！）

    return 0;
}

总结：**自定义类型必须用 new/delete：**不然构造 / 析构不执行，对象是 "半成品"；

**内置类型用 new/malloc 都行：**new 语法更简单，不用强转。

四、🔍【底层揭秘】new/delete 的 "幕后黑手"------operator new/delete

新手不用怕 "operator" 这个词，其实就是 C++ 给 new/delete 准备的 "工具函数"：

new 的底层：先调operator new申请空间，再调构造函数；

delete 的底层：先调析构函数，再调operator delete释放空间。

1. 新手能懂的底层逻辑（简化版）

// operator new：就是封装了malloc，失败抛异常（新手不用写，系统自带）
void *operator new(size_t size)
{
    void *p = malloc(size); // 底层还是malloc
    if (p == NULL) {
        throw bad_alloc(); // 失败不返回NULL，抛异常（新手记：new不用判空）
    }
    return p;
}

// operator delete：封装了free
void operator delete(void *p)
{
    if (p != NULL) {
        free(p); // 底层还是free
    }
}

1.operator new不是 "new 的重载"：是系统全局函数，不用改，会用就行；

2.new 申请失败：不会返回 NULL，会抛异常（新手如果想判空，可以用new (nothrow) int）；

3.可以自定义：比如给某个类写专属的 operator new，实现内存池（暂时不用学，先会用默认的）

五、🧩【高级玩法】定位 new------ 内存池的 "好搭档"

定位 new = 在已经申请好的内存上，调用构造函数初始化对象（相当于 "给毛坯房装修"）。

#include <iostream>
using namespace std;

class A
{
public:
    A(int a = 0) : _a(a) { cout << "A()：初始化_a=" << _a << endl; }
    ~A() { cout << "~A()：清理_a=" << _a << endl; }
private:
    int _a;
};

int main()
{
    // 1. 先用malloc申请"毛坯房"（只给空间，没初始化）
    A* p = (A*)malloc(sizeof(A));
    if (p == NULL) {
        cout << "malloc失败！" << endl;
        return -1;
    }

    // 2. 定位new：给"毛坯房装修"（调构造函数）
    new(p)A(20); // 格式：new(内存地址)类名(参数)

    // 3. 手动调析构函数（新手最容易忘！malloc/free不会自动调）
    p->~A();

    // 4. 释放"毛坯房"
    free(p);
    p = NULL;

    return 0;
}

2. 核心注意（记）
   1.定位 new 不申请新内存：只负责 "初始化"，内存得先自己申请；
   2.必须手动调析构：不然对象的资源（比如开的文件、堆内存）会漏；
   3.用在哪？：内存池（暂时不用，知道有这东西就行）。

六、❌【避坑指南】内存泄漏 ------ "头号敌人"

新手写代码最容易犯的错就是内存泄漏，先搞懂 "啥是泄漏"，再学怎么防。

1. 啥是内存泄漏？

**你用 new/malloc 申请了堆内存，不用了却没释放，**程序也忘记录这个内存的地址了 ------ 这块内存就成了 "孤儿内存"，系统拿不回来，你也用不了 ，占着茅坑不拉屎，就是内存泄漏。
2. 为啥可怕？（危害）

短程序（比如写个计算器）：漏一点没事，程序关了系统会回收；

长程序（比如服务器、游戏）：漏的内存越积越多，最后内存满了，程序崩了（写后台程序一定要注意！）。

3.如何检测

4.如何避免呢

1.申请和释放 "成对写"：写 new 的时候，马上写 delete（注释标好）；

2.释放后置 NULL：避免野指针，也能防止重复释放；

3.用智能指针（C++11+）：新手入门先学unique_ptr，自动释放内存（后面会讲）；

4.少用全局动态内存：全局变量生命周期长，容易忘释放；

5.调试时检查：写完代码跑一遍检测工具，早发现早改。
6.智能指针入门（最简单的防泄漏方法）

#include <memory> // 必须包含头文件
using namespace std;

int main()
{
    // 用unique_ptr代替new，不用手动delete！
    unique_ptr<int> p(new int(10));
    *p = 20; // 用起来和普通指针一样

    // 程序结束，unique_ptr会自动调delete，不会泄漏！
    return 0;
}

七、📝【面试必背】malloc/free vs new/delete（新手版对比）

记忆口诀：C 函数要判空，C++ 操作符自动调构造；申请要匹配，释放别忘记。

八、🎯【总结】新手记忆口诀 + 核心考点回顾
1. 核心口诀（记死）

内存分布：栈下堆上，静态全局在数据段，常量代码不能改；

内存申请：C 靠函数要判空，C++ 靠操作符，自定义类型看构造；

内存释放：单个用 delete，数组用 delete []，释放后置 NULL；

防泄漏：申请释放成对写，智能指针来帮忙。
2. 新手必掌握的核心点

能分清栈、堆、数据段的存储内容（笔试必考）；

会用 new/delete，知道和 malloc/free 的核心区别；

能识别内存泄漏，知道怎么检测和避免；

记住 new [] 和 delete [] 必须成对，释放后置 NULL。
3. 新手进阶方向

学智能指针（unique_ptr/shared_ptr）：彻底告别内存泄漏；

了解内存池：优化内存分配效率；

练笔试真题：sizeof/strlen 计算题、内存分布判断题。