【c++】第六章 内存高级话题

第1节  new、delete进一步认识

一、综述与回顾：第一章第4节、第四章第2节

二、从new说起

int *p1 = new int;    //初值随机
int *p2 = new int();    //初值给0

1、new对象时加括号与否的区别

int *p1 = new A;
int *p2 = new A();

1）若类A为空类：没有区别

2）若类A中有成员变量：带括号的初始化会把一些和成员变量有关的内存请零（不是全部）

3）若类A中有构造函数：m_i等成员变量的问题就交给构造函数了，带不带括号的效果一样

2、new和delete都干了啥（测试方法：调试——窗口——反汇编）

new首先调用了operator new函数，这个函数中调用了malloc函数，然后调用了A::A()构造函数；

delete首先调用了A::~A()析构函数，然后调用了operator delete函数，这个函数中调用了free函数。

注：malloc和free这一层再往下走就不是跨平台的了。

 

第2节  new细节探秘、重载类内operator new和operator delete

一、new内存分配细节探秘

通过代码测试，一段内存的回收影响的范围会很大（比如new的时候编译器会记录要分配的字节数供delete时候使用）

二、重载类中的operator new和operator delete（包括operator new[ ]和operator delete[ ]）

class A {
public:
    A(){
    cout << "gou" << endl;
    }
    ~A(){
    cout << "xi" << endl;    
    }
    static void* operator new(size_t size);
    static void operator delete(void* phead);
    static void* operator new[](size_t size);
    static void operator delete[](void* phead);
};
void* A::operator new(size_t size) {
    A *point = (A*)malloc(size);
    return point;
}
void* A::operator new[](size_t size) {    
    //这里传进来的是7，其中每个对象1个字节，再加上4个字节用来存放数组长度3
    A *point = (A*)malloc(size);
    return point;
}
void A::operator delete(void* phead){
    free(phead);
}
void A::operator delete[](void* phead) {
    free(phead);
}
void func() {
    A *p1 = new A();
    delete p1;
    A *p2 = new A[3]();
    //new对象的数组时，构造函数和析构函数都调用3次，但是operator new和operator delete都调用1次
    delete[] p2;
}

 

第3节  内存池概念、代码实现详细分析

一、内存池的概念和实现原理概述

内存池解决问题：减少malloc的次数，也就是减少对内存的浪费，而且比malloc要快一点。

实现原理：用malloc一次申请一大段内存，然后一点一点分配给用户。

二、一个类的内存池实例

operator new图示（每次new的时候返回tmplink给新指针，，m_FreePost指向下一个空的内存，如果用完了就再新建）：

      

operator delete图示（先连起来，再让m_FreePost指向释放后的内存地址）：

代码如下 ：

class A {
//#define MYMEMORYPOOL 1
public:
    A() {}
    ~A() {}
    static void* operator new(size_t size);
    static void operator delete(void* phead);
    static int m_iCount;
    static int m_iMallocCount;
private:
    A* next;
    static A* m_FreePosi;	//总是指向可以分配出去内存的首地址
    static int m_sTrunkCount;	//一次分配多少倍的内存
};
int A::m_iCount = 0;
int A::m_iMallocCount = 0;
A* A::m_FreePosi = nullptr;
int A::m_sTrunkCount = 5;

void* A::operator new(size_t size) {
    //这里的size每次都是4个字节，因为里面有个next指针占用4字节
#ifdef MYMEMORYPOOL
    A *point = (A*)malloc(size);
    return point;
#endif
    //内存池核心实现代码
    A *tmp;
    if (m_FreePosi == nullptr) {
        //为空，我要申请内存
    	size_t realsize = m_sTrunkCount * size;
	m_FreePosi = reinterpret_cast<A*>(new char[realsize]);	
        //这个new调用的是系统的malloc，这个时候应该自动分了
	tmp = m_FreePosi;	
        //这样tmp也是指向这一大块内存的首地址
	//五小块要链接起来
	for (; tmp != &m_FreePosi[m_sTrunkCount - 1]; ++tmp) {
	    cout << tmp << endl;
            tmp->next = tmp + 1;
	}
	tmp->next = nullptr;
	++m_iMallocCount;
    }
    //上述代码利用tmp链接了几个内存块
    //如果if不满足，其实就是返回m_FreePosi，然后m_FreePosi往下走一个
    tmp = m_FreePosi;
    m_FreePosi = m_FreePosi->next;
    ++m_iCount;
    return tmp;
}

void A::operator delete(void* phead) {
#ifdef MYMEMORYPOOL
    free(phead);
#endif 
    (static_cast<A*>(phead))->next = m_FreePosi;
    m_FreePosi = static_cast<A*>(phead);
}

void func() {
    clock_t start, end;
    start = clock();
    for (int i = 0; i < 15; i++) {
	A *pa = new A();
	/*cout << pa << endl;*/
    }
    end = clock();
    cout << "申请总内存次数：" << A::m_iCount << endl;
    cout << "调用malloc次数：" << A::m_iMallocCount << endl;
    cout << "用时：" << end - start << endl;
}

运行结果（每一次分配的 最后一个为空，所以没有显示）：

三、内存池代码后续说明

delete很麻烦，所有释放的内存一直在内存池手里，不会归还给操作系统！

 

第4节  嵌入式指针概念及范例、内存池改进版

一、嵌入式指针（embedded pointer）

一般应用在内存池相关的代码中，使用前提是sizeof(A)>4

工作原理：借用A对象所占用内存的前4个字节，用来链住空闲的内存块。

class TestEP {
public:
    int m_i;
    int m_j;
public:
    struct obj {
        //嵌入式指针，指向一个obj结构对象
        struct obj* next;
    };
};
void func() {
    TestEP mytest;
    cout << sizeof(mytest) << endl;
    TestEP::obj *ptemp;
    ptemp = (TestEP::obj*)&mytest;    //ptemp指向mytest对象首地址
    //ptemp和ptemp->next是一个地址	
    ptemp->next = nullptr;
    //这里的nullptr换成下一个内存的首地址，链起来就是第三节的内容了
}

二、内存池代码的改进：单独为内存技术写一个类！

 

第5节  重载全局new、delete、定位new及重载等

一、重载全局new、delete（一般都在类里）

void * operator new(size_t size) {
    return malloc(size);
}
void * operator new[](size_t size) {
    return malloc(size);
}
void operator delete(void *phead){
    free(phead);
}
void operator delete[](void *phead) {
    free(phead);
}

二、定位new（placement new） 没有placement delete

功能：在已经分配的原始内存中初始化一个对象（调用构造函数）

格式：类名 *指针变量名 = new (内存首地址) 类名();

class A {
public:
    int m_a;
    A() {
	cout << "构造函数A::A()" << endl;
    }
    A(int tmp):m_a(tmp){
        cout << "构造函数A::A(int)" << endl;
    }
    ~A() {
        cout << "析构函数A::~A()" << endl;
    }
    void* operator new(size_t size,void* phead) {
        return phead;
    }
};
void func() {
    void* p = (void*)new char[sizeof(A)];
    A* test1 = new(p) A();	//调用无参构造函数，并不分配内存
    void* p2 = (void*)new char[sizeof(A)];
    A* test2 = new(p2) A(12);
    
    /*delete test1;
    delete test2;*/
    
    test1->~A();    //可以手工调用析构函数
    test2->~A();
    delete (void*)test1;
    delete[](void*)test2;
}

placement new的重载：多个参数但是不分配内存

三、多种版本的operator new重载

A *pa = new(123,456) A();    //第一个参数必须为size，这两个参数分别为第二、三个参数