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";
    char* pChar3="abcd";
    
    int* ptr1=(int*)malloc(sizeof (int)*4);
    int* ptr2=(int*)calloc(4,sizeof(int));
    int* prt3=(int*)realloc(ptr,sizeof(int)*4);
	
    free(ptr1);
    free(ptr3);
}
1. 选择题：
 选项: A.栈 B.堆 C.数据段 D.代码段
 globalVar在哪里？__C__ staticGlobalVar在哪里？__C__
 staticVar在哪里？_C___ localVar在哪里？__A__
 num1 在哪里？__A__
 
 char2在哪里？__A__ *char2在哪里？_A__
 pChar3在哪里？_A___ *pChar3在哪里？_D___
 ptr1在哪里？__A__ *ptr1在哪里？_B___
2. 填空题：
 sizeof(num1) = __40__; 
 sizeof(char2) = __5__; strlen(char2) = __4__;
 sizeof(pChar3) = __4__; strlen(pChar3) = __4__;
 sizeof(ptr1) = __4__;

• 全局和静态变量都在数据段（C语言中称为静态区）【静态区分为初始化和未初始化】
  • globalVar和staticGlobalVar在main函数之前就初始化
  • 上两个作用域是全局的
    • 这两个全局的有什么区别？链接属性不一样
    • globalVar全部文件都能看到
    • staticGlobalVar只在当前文件可见
  • static 运行到该位置再初始化
  • 作用域是局部的
• 常量在代码段
• 

这部分在linux下已经学习过了。

• 操作系统内存管理：
  1. 分段。
     1. 不同用途的数据放到不同的区域，就像我们现实中也会对杭州划分区域一样
  2. 分页。
     1. 页表映射
• 一个写出来程序在Linux是如何被编译后运行起来的
  1. 编写的代码是存在文件系统上
  2. 编译器去读这个程序，通过编译链接生成可执行程序a.out
  3. ./a.out在一个终端下去运行程序，运行程序a.out相当于终端创建了一个子进程，exec对创建的子进程进行替换，替换成a.out

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

2.1malloc/calloc/realloc和free

面试题：malloc/calloc/realloc的区别

• 三者区别
  • malloc申请空间
    • 开辟指定字节大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。传参时只需传入需要开辟的字节个数。
  • calloc申请初始化0
    • 也是开辟指定大小的内存空间，如果开辟成功就返回该空间的首地址，如果开辟失败就返回一个NULL。calloc函数传参时需要传入开辟的内存用于存放的元素个数和每个元素的大小。calloc函数开辟好内存后会将空间内容中的每一个字节都初始化为0。
  • realloc对原来的空间扩容
    • realloc函数调整动态内存大小的时候会有三种情况：
      • 原地扩。需扩展的空间后方有足够的空间可供扩展，此时，realloc函数直接在原空间后方进行扩展，并返回该内存空间首地址（即原来的首地址）。
      • 异地扩。需扩展的空间后方没有足够的空间可供扩展，此时，realloc函数会在堆区中重新找一块满足要求的内存空间，把原空间内的数据拷贝到新空间中，并主动将原空间内存释放（即还给操作系统），返回新内存空间的首地址。
      • 扩充失败。需扩展的空间后方没有足够的空间可供扩展，并且堆区中也没有符合需要开辟的内存大小的空间。结果就是开辟内存失败，返回一个NULL。

3.C++内存管理方式

3.1C++出现new和delete的原因

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

cpp的new和delete出现的两个原因：

1. 自定义类型对象自动申请的时候，初始化和清理问题。new/delete会调用构造函数和析构函数
2. new失败了以后要求抛异常，这样才符合面向对象语言的出错机制
   1. 面向过程的处理语言的方式处理错误的方式是错误码+返回值
   2. 面向对象的语言处理错误的方式一般是抛异常,C++中也要求出错抛异常

Tips：free和delete不会失败，如果失败了，都是释放空间上存在越界或释放指针位置不对。

3.2new/delete操作内置类型

先来回顾下C语言中是怎么做的?

3.2.1动态申请单个内置类型

C语言方式:

int main(){
    
    int* p1 = (int*)malloc(sizeof(int));//动态申请int
	free(p1);
}

Cpp方式:

int main()
{
    int* p2 = new int;
    delete p2;
}

动态申请并且初始化

int main()
{
    int* p3= new int(5);//申请一个int的4个字节空间，初始化成5
    delete p3;
}

3.2.2动态申请多个内置类型

C语言方式:

  int* p2 = (int*)malloc(sizeof(int)*5);//动态申请5个int数组
  free(p2);

Cpp方式:

new int(10)和new int[10]是有不同意义的。注意C++98不支持初始化new的数组,c++11支持new int[5]{1,2}。

int main()
{
    int* p4=new int[10];//申请10个int的40个字节空间
    delete[] p4;
}

动态申请并初始化

   int* p5=new int[5]{1,2};//c++11支持申请空间时初始化
    delete[] p5;

总结：malloc/free和new/delete对于内置类型没有本质区别，只有用法上的区别

3.3new和delete的操作自定义类型

3.3.1new操作自定义类型

c++讲究是定义的时候就完成初始化，malloc是没法做到的。比如默认的构造函数，定义对象的自动调用默认的。

当面对自定义类型的时候，new不但会在堆上申请对象空间+调用构造函数初始化对象

calloc只能初始化成0，而new则可以调用构造函数进行任意的初始化。

class A{
    public:
    A(int a=0)
        :_a(a)
    {cout<<"A()"<<endl;}
    ~A(){
        cout<<"~A()"<<endl;
    }
    private:
    	int _a;
};
int main(){
    A* p1 = (A*)malloc(sizeof(A));
    A* p2 = (A*)malloc(sizeof(A)*5);
    
    A* p3 = new A;
    A* p4 = new A[5];
}

假如没有默认构造函数怎么处理？类似 new int(10)

class A{
    public:
    A(int a)
        :_a(a)
    {cout<<"A()"<<endl;}
    ~A(){
        cout<<"~A()"<<endl;
    }
    private:
    	int _a;
};
int main(){
    A* p3 = new A(10);
    A* p4 = new A[5]{10};
}

3.3.2delete操作自定义类型

当面对自定义类型的时候，delete先调用指针类型析构函数，给堆上释放空间

class A
{
    A(int a=1)
    :a(_a)
    {
        cout<<"A()"<<endl;
    }
    ~A(){
        cout<<"~A()"<<endl;
    }
    private:
    	int _a;
};
int main()
{
    int* p1=new int;
    int* p2=(int*)malloc(sizeof(int));
    
    A* p3=(A*)malloc(sizeof(A));
    A* p4=new A;
    
    free(p1);
    free(p2);
    
}

对于下面的场景:如果不对MyQueue进行delete要去调用默认析构函数从而调用Stack的析构函数。

class MyQueue
{
    private:
    	Stack _s1;
    	Stack _s2;
};

delete的[]是什么意思？

告诉编译器这是数组，有多个对象，会自动去取有多少个对象，从而进行反复调用多少次析构函数。

3.3.3new和malloc,delete和free混用乱用存在的问题

Cpp和C的接口不要乱混用，不然就会产生不可预知的行为。

同时注意数组的就要用delete[]，单个对象的就用delete，用错了就会aborted。

使用 char* p = new char[100]申请一段内存，然后使用delete p释放，有什么问题？

对于内置类型，此时delete就相当于free，因此不会造成内存泄漏。

编译不会报错，建议针对数组释放使用delete[],如果是自定义类型，不使用方括号就会运行时错误。

对于内置类型，程序不会崩溃，但不建议这样使用。

3.4new和delete的底层原理

new和delete是用户进行动态内存申请和释放的操作符，operator new和operator delete是系统提供的全局函数，new和delete在底层是通过调用全局函数operator new和operator delete来申请和释放空间的。

Cpp也要抛出异常的原因

1. 面向过程的处理语言的方式处理错误的方式是错误码+返回值
2. 面向对象的语言处理错误的方式一般是抛异常,C++中也要求出错抛异常。异常的错误需要是有人throw出来的，而new中是出错了会throw的。

我们直接malloc很大的一块空间，按照进程地址空间，基本3G是整个用户空间。

int main()
{
    char* p1 = (char*)malloc(1024u*1024u*1024u*3);
    if( p1 == NULL )
    {
        printf("%d\n",errno);
        perror("malloc fail");
        exit(-1);
    }
	else{
        printf("%p\n",p1);
    }
}

我们再尝试new一块这么大的空间。

int main()
{
    char* p1=nullptr;
    try{
         p1 = new char[1024u*1024u*1024u*3];
         printf("%p\n",p1);
    }
    catch(const exception & e){
        cout<<e.what()<<endl;
    }
}

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

3.4.1.1operator new和operator delete的用法

operator new和operator delete的用法和malloc和free的用法完全一样，其功能都是在堆上申请和释放空间。

malloc和free：

struct ListNode{
	ListNode* _prev;
    ListNode* _next;
    int _val;
    
    ListNode(int val)
    	:_next(nullptr),
    	_prev(nullptr),
    	_val(val)
    {	}    
};
int main()
{
	ListNode* p1 = (ListNode*)malloc(sizeof(ListNode));
    free(p1);
}

operator new和operator delete：

struct ListNode{
	ListNode* _prev;
    ListNode* _next;
    int _val;
    
    ListNode(int val)
    	:_next(nullptr),
    	_prev(nullptr),
    	_val(val)
    {	}    
};
int main()
{
	ListNode* p2 = (ListNode*)operator new(sizeof(ListNode));
    operator delete(p2);
}

3.4.1.2operator new 和operator delete失败后的处理方式

如何验证operator new会抛出异常呢？我们使用和测试new一样的方式，测试operator new。

malloc失败后只会返回错误码。

int main()
{
    void* p4=malloc(3*1024u*1024u*1024u);//主要是会溢出
    if(p4 == nullptr){
        cout<<"malloc failed"<<endl;
        perror(errno);
        exit(-1);
    }
    cout<<p4<<endl;
}

而operator delete失败后是抛出异常。

int main()
{
    try{
        void* p5=operator new(3*1024u*1024u*1024u);
        cout<<"hello world"<<endl;//抛出异常跳过这一句
    }
    catch(exception& e)//失败抛异常(面向对象处理方式)
    {
        cout<<e.what()<<endl;
    }
}

3.4.1.3operator new 和operator delete的源码

operator new的源码：

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，
尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
    // try to allocate size bytes
    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);
}

free的实现:

free 也会失败，但是失败了直接exit(-1)了

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

operator delete的实现:

/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void *pUserData)
{
    _CrtMemBlockHeader * pHead;
    RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
    if (pUserData == NULL)
        return;
    _mlock(_HEAP_LOCK); /* block other threads */
    __TRY
        /* get a pointer to memory block header */
        pHead = pHdr(pUserData);
    /* verify block type */
    _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
    _free_dbg( pUserData, pHead->nBlockUse );//这里就是free的实现
    __FINALLY
        _munlock(_HEAP_LOCK); /* release other threads */
    __END_TRY_FINALLY
        return;
}

所以两者没有什么区别

3.4.1.4重载一个类专属的operator new和operator delete

库函数中有一个全局的operator new和operator delete。

下面代码演示了，针对链表的节点ListNode通过重载类专属operator new/ operator delete，实现链表节点使用内存池申请和释放内存，提高效率。

类似线程池，提前申请好内存。面对不断申请内存的情况一种提高效率的办法。

struct ListNode
{
    ListNode* _next;
    ListNode* _prev;
    int _data;
    
    void* operator new(size_t n)//重载类的专属operator new
    {
        void* p=nullptr;
        p=allocator<ListNode>().allocate(1);//STL中的空间配置器——内存池
        cout<<"memory pool allocate"<<endl;
        return p;
    }
    void operator delete(void* p)
    {
        allocator<ListNode>().deallocate((ListNode*)p,1);
        cout<<"memory pool allocate"<<endl;
    }
};
class List
{
    public:
    List()
    {
        _head = new ListNode;
        _head->_next = _head;
        _head->_prev = _head;
    }
    ~List()
    {
        ListNode* cur = _head->_next;
        while (cur != _head)
        {
            ListNode* next = cur->_next;
            delete cur;
            cur = next;
        }
        delete _head;
        _head = nullptr;
    }
    private:
    ListNode* _head;
};
int main()
{
    List l;
    return 0;
}

3.5new和delete的小结

• 对于内置类型：

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

• 对于自定义类型：

  • new的原理

    • 调用operator new申请空间
    • 在申请的空间上执行构造函数，完成对象的构造

  • delete的原理

    • 在空间上执行析构函数，完成对象中的资源清理工作
    • 调用operator delete函数释放对象的空间

• new T[N]的原理

  • 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象的申请
  • 在申请的空间上执行N次构造函数

• delete[]的原理

  • 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
  • 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

4.定位new表达式(placement-new)

4.1概念

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。

一般来说，使用new申请空间时，是从系统的“堆”（heap）中分配空间。申请所得的空间的位置是根据当时的内存的实际使用情况决定的。但是，在某些特殊情况下，可能需要在已分配的特定内存创建对象，这就是所谓的“定位放置new”（placement new）操作。 即显式调用构造函数初始化这块空间。

4.2使用场景

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

考虑如下场景：假设有一块空间已经被动态申请出来了。A* p =(A*)malloc(sizeof(A));而malloc没有初始化功能,而且_a是private。现在需要调用构造函数初始化。

向内存池获取内存就不是直接向系统使用new申请，因此不会调用对象的构造函数，那么如果调用构造函数呢？

class A
{
    public:
    	A(int a)
            :_a(a)
            {
                cout<<"A()"<<endl; 
            }
    		~A()
        	{
            	cout<<"~A()"<<endl;
        	}
    private:
    	int _a;
};
int main()
{
    A* p =(A*)malloc(sizeof(A));
    //p->_a =3;肯定是不行的
    ///这里有一个方法---对已经存在的一块空间调用构造函数初始化
    new(p)A;//定位new,placement-new,显式调用构造函数初始化这块对象空间
    new(p2)A(10);//显式调用构造函数
}

意义：比如内存不想找系统要(new可以直接调用构造)，而找内存池获取空余内存(是没有调用new的)。我们可以通过该方法对该空间上的对象进行调用构造函数和析构函数

class A
{
    public:
    	A(int a)
            :_a(a)
            {
                cout<<"A()"<<endl; 
            }
    		~A()
        	{
            	cout<<"~A()"<<endl;
        	}
    private:
    	int _a;
};
int main()
{
    //等价于直接new A
    A* p =(A*)operator new(sizeof(A));//失败抛异常
    new(p)A;//定位new,placement-new,显式调用构造函数初始化这块对象空间
    
    //等于delete p;
    p->~A();//析构函数可以显式调用。完成对象的资源释放的孔家
    operator delete(P);//释放该对象所在空间
}

使用格式：

new (place_address) type或者new (place_address) type(initializer-list)

place_address必须是一个指针，initializer-list是类型的初始化列表

4.3小结

构造函数不能显式调用，构造对象自定义调用或者定位new。

而析构函数可以直接调用。

5.常见面试题

5.1malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。

• 不同的地方是：
  • malloc和free是函数，new和delete是操作符
  • malloc申请的空间不会初始化，new可以初始化
  • malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
  • malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
  • malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
  • 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间 后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

5.2内存泄漏

5.2.1内存泄漏的概念和危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会 导致响应越来越慢，最终卡死。

int main()
{
	//1G
    char* p=new char[1024*1024*1024];
    //内存泄漏:p指向的空间不需要了，忘记或其他原因没释放p指向的空间，就内存泄漏 
    return 0;
}

5.2.2内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

• 堆内存泄漏（Heap leak）
  • 堆内存指的是程序执行中依据须要分配通过malloc/calloc/realloc/new等从堆中分配的一块内存， 用完后必须通过调用相应的free或者delete删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生HeapLeak。
• 系统资源泄漏
  • 指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。比如僵尸进程等

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

在linux下内存泄漏检测：linux下几款内存泄漏检测工具

在windows下使用第三方工具：VLD工具说明

其他工具：内存泄漏工具比较

7.2.4如何避免内存泄漏

大致两种：

1. 事前预防性：智能指针等
2. 事后差错型：内存泄漏工具

7.3如何一次在堆上申请4G的内存

换成X64就可以申请了。X32位不够。

int main()
{
    size_t n=2;
    void* p=new char[n*1024*1024*1024];//抛出异常
}