文章目录

前言
后记

前言

本文将讲述C++内存管理的相关知识。

持续更新中~

1. C/C++内存分布

我们由问题来引出话题。

首先，先来看一下这段代码：

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);
}

请回答下列问题：

是不是对你来说有那么点挑战，有几个还不确定？

我讲述一下易错的几个点：

选择题

下面字符串的判断容易搞混，char2和*char2是字符数组，是在栈上的。

pCharp是指向常量区的一个指针，指向“abcd”，

解引用的*pChar也就是“abcd”就在常量区

ptr1是指针哦，注意分辨，它申请的空间是在堆上面的

所以*ptr1就是在堆上

填空题

数组num1开辟了十个空间哦，注意看它中括号里面的值，如果一个数组定义时，中括号里面没有值，就只看后面花括号内的值。

字符串大小判断需要记得还有一个‘\0’隐藏起来了，使用sizeof时‘\0’也会算在结果中的，而strlen则不管‘\0’，只算’\0’前面的字符。

还要注意的是，求大小的是“指针”还是“字符串or数组”？

是指针则根据环境的不同，它的大小是4 or 8

以下就是答案了

图示：

在这里插入图片描述

栈又叫堆栈–非静态局部变量/函数参数/返回值等等，栈是向下增长的。
内存映射段是高效的I/O映射方式，用于装载一个动态内存库。用户可使用系统接口创建共享内存，做进程间通信。（之后会在linux中讲的）
堆用于程序运行时动态内存分配，堆是可以向上增长的。
数据段–存储全局数据和静态数据。
代码段–可执行的代码/只读常量

小结：这一个知识点，我们配合题目，解析，图示很容易理解的，记住就好。

2. C语言中动态内存管理方式

看下面代码：
思考注释中的问题

void Test ()
{
    int* p1 = (int*) malloc(sizeof(int));
    free(p1);
    
    // 1.malloc/calloc/realloc的区别是什么？
    int* p2 = (int*)calloc(4, sizeof (int));
    int* p3 = (int*)realloc(p2, sizeof(int)*10);
    
    // 这里需要free(p2)吗？
    free(p3 );
}

我相信只要你学过c语言都不会对它们陌生的，我就来帮你总结一下它们。

拓展：

3. C++中动态内存管理

3.1 new/delete操作内置类型

看下面代码：

注释中就是new/delete的使用方法

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

图示：

在这里插入图片描述

3.2 new和delete操作自定义类型

看下面代码：

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));//C
    //1、堆上申请空间  2、调用构造函数初始化
    A* p2 = new A(1);
    free(p1);//C
    // 1、调用析构函数清理对象中资源 2、释放空间
    delete p2;
    
    // 内置类型是几乎是一样的
    int* p3 = (int*)malloc(sizeof(int)); // C
    int* p4 = new int;
    free(p3);//C
    delete p4;
    
    A* p5 = (A*)malloc(sizeof(A)*10);//C
    A* p6 = new A[10];
    free(p5);
    delete[] p6;
    
    //在C++11中还有一种初始化的方式，先了解即可，之后会再讲的
   	A* p7 = new A[2]{1,2};
	A* p8 = new A[2]{ A(1), A(2) };
    delete[] p7;
    delete[] p8;
    return 0;
}
//结论：new/delete 是为自定义类型准备的。
// 不仅在堆中申请出来，还会调用构造和析构初始化和清理

4. operator new与operator delete函数

4.1 operator new与operator delete函数（重点）

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
    // 尝试分配size大小字节
    void *p;
    while ((p = malloc(size)) == 0)
    if (_callnewh(size) == 0)
      {
        // report no memory
        // 如果申请内存失败了，这里会抛出bad_alloc 类型异常
        static const std::bad_alloc nomem;
        _RAISE(nomem);
      }
    return (p);
}

void operator delete(void *pUserData)
{
    _CrtMemBlockHeader * pHead;
    RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
    if (pUserData == NULL)
        return;
    _mlock(_HEAP_LOCK);  /* 释放其他线程 */
    __TRY
        /* 获取指向内存块首地址的指针 */
        pHead = pHdr(pUserData);
    /* 验证块类型 */
    _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
    _free_dbg( pUserData, pHead->nBlockUse );
    __FINALLY
        _munlock(_HEAP_LOCK);  /* 释放其他线程 */
    __END_TRY_FINALLY
    return;
}

#define  free(p)        _free_dbg(p, _NORMAL_BLOCK)

5. new和delete的实现原理

5.1 内置类型

5.2 自定义类型

6. 定位new表达式(placement-new)（了解即可）

class A
{
    public:
    A(int a = 0)
    : _a(a)
    {
    	cout << "A():" << this << endl;
    }
    ~A()
    {
    	cout << "~A():" << this << endl;
    }
    private:
    int _a;
};
// 定位new/replacement new
int main()
{
    // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
    A* p1 = (A*)malloc(sizeof(A));
    new(p1)A;  // 注意：如果A类的构造函数有参数时，此处需要传参
    p1->~A();
    free(p1);
    A* p2 = (A*)operator new(sizeof(A));
    new(p2)A(10);
    p2->~A();
    operator delete(p2);
     return 0;
}

7. 常见面试题

7.1 malloc/free和new/delete的区别

7.2 内存泄露

7.2.1 什么是内存泄漏，内存泄漏的危害

void MemoryLeaks()
{
     // 1.内存申请了忘记释放
     int* p1 = (int*)malloc(sizeof(int));
     int* p2 = new int;
     // 2.异常安全问题
     int* p3 = new int[10];
     Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
     delete[] p3;
}

7.2.2 内存泄漏分类（了解即可）

7.2.3 如何检测内存泄漏（了解即可）

int main()
{
    int* p = new int[10];
    // 将该函数放在main函数之后，每次程序退出的时候就会检测是否存在内存泄漏
    _CrtDumpMemoryLeaks();
    return 0;
}

// 程序退出后，在输出窗口中可以检测到泄漏了多少字节，但是没有具体的位置
Detected memory leaks!
Dumping objects ->
{79} normal block at 0x00EC5FB8, 40 bytes long.
Data: <         > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.

7.2.4如何避免内存泄漏

后记

我已经快一个没有更新了，前段时间是期中考试四门专业课有点忙，今后继续保持记录和输出，我还会开一个刷题专栏，感谢大家支持！！！

在这里插入图片描述
respect！

下篇见！