C++内存管理详细解析

目录

• 一、C++内存管理
  • 1、 new/delete表达式
  • 2、new/delete重载
  • 3、类内自定义allocator（per-class allocator）
• 二、多线程内存分配器
  • 1、malloc/free
  • 2、brk和mmap
• 三、补充知识
  • 1、内存泄漏
  • 2、malloc/free和new/delete的比较
  • 3、RAII规则

// c语言中的malloc/free
void *p1 = malloc(512);
*(int*) p1 = 100;
free(p1);

// c++表达式new/delete 
int *p2 = new int(100);// 这里应该是初始化为100，若要声明数组，用new int[n];
delete p2;

// c++函数，等价于malloc和free
void *p3 = ::operator new(512);
*(int *)p3 = 100;
::operator delete(p3);

// c++标准库，通过object调用，以GNU为例
int *p4 = alloctor<int>().allocate(7);// 这里是分配7个int单元而不是7bytes
*p4 = 9;
allocator<int>().deallocate((int *)p4,7);// 7应该与上文匹配

Complex *pc;
try {
   void* mem = operator new(sizeof(Complex)); // 分配内存
   pc = static_cast<Complex*>(mem);    // cast 转型 以符合对应的类型，这里对应为Complex*
   pc->Complex::Complex(1,2); // construct
   // 注意：只有编译器才可以像上面那样直接呼叫constructor 欲直接调用constructor可通用placement new: new(p) Complex(1,2);
}
catch(std::bad_alloc) {
   // 若allocation失败就不执行constructor
}

// delete pc;
pc->~Complex();  //先析构
operator delete(pc);   //然后释放内存

class A{
public:
 int id;
 
    A(): id(0){}
    A(int i): id(i){}
    ~A(){}
};

A* buf = new A[size]; // 调用三次默认构造函数A():id(0)
A* tmp = buf;
// placement new指定位置new
for(int i = 0; i<size; i++)
    new(tmp++) A(i);  //调用A(int i): id(i)自定义初始化
delete []buf; // 调用三次~A()

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

#include <iostream>
#include <complex>
using namespace std;

class my_allocator{
    private:
     struct obj{
            struct obj* next;  // embedded pointer
        };
     obj* freestore = nullptr;
     const int CHUNK = 5;
    public:
     my_allocator(){};
     ~my_allocator(){};
     void* allocate(size_t);
     void deallocate(void*, size_t);
};

void* my_allocator::allocate(size_t size){
    // 从内存池分配一个obj对象大小的内存
    assert(size>0);
    obj* p;
    if(!freestore){
        freestore = p = static_cast<obj*>(malloc(CHUNK*size));
        for(int i = 0;i<CHUNK-1;i++){
            p->next = (obj*)((char*)(p+size));
            p = p->next;
        }
        p->next = nullptr;
    }
    p = freestore;
    freestore = freestore->next;
    return p;
}

void deallocate(void* p, size_t size){
    // 插入到内存池
    (static_cast<obj*>(p))->next = freestore;
    freestore = static_cast<obj*>(p);
}

// example
class Foo{
    public:
     long L;
     string str;
     static my_allocator myAlloc;
     Foo(long l): L(l){}
     static void* operator new(size_t size){
            return myAlloc.allocate(size);
        }
     static void operator delete(void* dead, size_t size){
            return myAlloc.deallocate(dead, size);
        }
};
my_allocator Foo::myAlloc; // 静态成员变量一定要在类声明之外定义

static const int __ALLGN = 8; // 上调边界
static const int __MAX_BYTES = 8; // 分配Chunk的上限
static const int __NFREELISTS = __MAX_BYTES/__ALLGN; // 链表的条数

template<bool threads, int inst>
class __default_alloc_template{
 private:
  static size_t ROUND_UP(size_t bytes){ // 向上取整8 
   return (bytes+__ALLGN-1) & ~(__ALLGN-1);
  }
  union obj{ // 亦可用struct
   union obj* free_list_link; // 链表的next指针，老规矩用了ebedded pointer
  }
  static obj* volatile free_list[__NFREELISTS]; // 多级大小内存池
  static size_t FREELIST_INDEX(size_t bytes){ // 根据大小确定链表index
   return ((bytes+ALLGN-1)/__ALLGN-1);
  }
  static void *refill(size_t size);
  static char* chunk_alloc(size_t size, int &nobjs);
  
  // 战备池
  static char* start_free; // 指向pool的头
  static char* end_free; // 指向pool的尾
  static size_t heap_size; // 分配累积量
  
 public:
  static void* allocate(size_t size){
   obj* volatile *my_free_list; // 链表的链表
   obj* result;
   
   if(size > (size_t)__MAX_BYTES) // 大于128改用第一级分配器
    return (malloc_alloc::allocate(size));
   my_free_list = free_list+FREELIST_INDEX(size);
   result = *my_free_list;
   if(0==result){
    void* t = refill(ROUND_UP(size)); // 对此链表充值
    return t;
   }
   *my_free_list = result->free_list_link;
   return result;
  }
  static deallocate(void* p, size_t size){
            obj* q = (obj*)p;
            obj* volatile* my_free_list;
   if(size > static_cast<size_t>(__MAX_BYTES)){
    malloc_alloc::deallocate(p,size); // 大于128改用第一级分配器
    return;
   }
   my_free_list = free_list + FREELIST_INDEX(size);
   q->free_list_link = *my_free_list;
   *my_free_list = q;
  }
  static void* reallocate(void* p, size_t old_size,size_t new_size);
}


/*
    We allocate memory in large chunks inn order to avoid fragmenting the malloc
   heap too much, We assume that size is properly aligned.
    We hold the allocation lock. 
*/
template<bool threads, int inst>
char* __default_alloc_template<threads, inst>::chunk_alloc(size_t size, int& nobjs) {
 
    char* result;
    size_t total_bytes = size * nobjs;
    size_t bytees_left = end_free - start_free;
    
    if(bytees_left >= total_bytes) {  //pool空间足以满足需求
 
        result = start_free;
        start_free += total_bytes; // 【Q1：如果pool中的空间不连续还能直接分配和相加吗？A：虚拟地址是连续的】
        return(result); 
    }else if(bytees_left >= size) {  //pool空间只满足一块以上
        
        nobjs = bytees_left / size;   //改变需求个数
        total_bytes  = size * nobjs;  //改变需求总量   pass-by-value会改变参数
        result = start_free;
        start_free += total_bytes;
        return (result); 
    }else {   //pool空间不足以满足一块需求  碎片&&0
 
        //打算从system free-store上去这么多来充值
        size_t bytes_to_get = 2 * total_bytes + ROUND_UP(heap_size >> 4);
        //处理碎片(将其挂到相应的chunk指针端口)
        if(bytes_to_get > 0) {
            obj* volatile *my_free_list =   //重新定位碎片的指针
               free_list + FREELIST_INDEX(bytees_left); 
            ((obj*)start_free)->free_list_link = *my_free_list;
            *my_free_list = (obj*)start_free; 
        }
 
        //从system free-store中取
        start_free = (char*)malloc(bytes_to_get); 
        if(0 == start_free) {  //如果当前的chunk分配失败，则向上继续找相邻的chunk继续分配
            obj* volatile *my_free_list, *p;
            for(int i = size; i <= __MAX_BYTES; i += __ALLGN) {
                my_free_list = free_list + FREELIST_INDEX(i); 
                p = *my_free_list;
                if(0 != p) {  //该free-list有可用区块
                    *my_free_list = p->free_list_link; 
                    start_free  = (char*)p;
                    end_free = start_free + i; 
                    return (chunk_alloc(size, nobjs));   //结果再试一次
                }
            }
            end_free = 0;
            start_free = (char*)malloc_alloc::allocate(bytes_to_get); 
        }
 
        //至此，表示已经从system free-store成功取得很多memory
        heap_size += bytes_to_get;
        end_free = start_free + bytes_to_get;
        return (chunk_alloc(size, nobjs));   //战备池有内存了，所以递归重新处理分配逻辑
    }
}
 
//静态定义(分配内存)
template<bool threads, int inst>
char* __default_alloc_template<threads, inst>::start_free = 0;
 
 
template<bool threads, int inst>
char* __default_alloc_template<threads, inst>::end_free = 0;
 
template<bool threads, int inst>
size_t __default_alloc_template<threads, inst>::heap_size = 0;
 
 
template<bool threads, int inst>
__default_alloc_template<threads, inst>::obj* volatile
__default_alloc_template<threads, inst>::free_list[__NFREELISTS] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
 
//std::alloc为第二级分配器
typedef  __default_alloc_template<false, 0> alloc;

int main(void){
    std::vector<int,MyAllocator<int>> v;
}