一、C++內(nèi)存管理

C++中有四種內(nèi)存分配、釋放方式：

最高級(jí)的是std::allocator，對(duì)應(yīng)的釋放方式是std::deallocate，可以自由設(shè)計(jì)來搭配任何容器；new/delete系列是C++函數(shù)，可重載；malloc/free屬于C++表達(dá)式，不可重載；更低級(jí)的內(nèi)存管理函數(shù)是操作系統(tǒng)直接提供的系統(tǒng)調(diào)用，通常不會(huì)到這個(gè)層次來寫C++應(yīng)用程序。接下來的闡述集中在上三層。

現(xiàn)在讓我們寫一些示例：

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

// c++表達(dá)式new/delete 
int *p2 = new int(100);// 這里應(yīng)該是初始化為100，若要聲明數(shù)組，用new int[n];
delete p2;

// c++函數(shù)，等價(jià)于malloc和free
void *p3 = ::operator new(512);
*(int *)p3 = 100;
::operator delete(p3);

// c++標(biāo)準(zhǔn)庫，通過object調(diào)用，以GNU為例
int *p4 = alloctor<int>().allocate(7);// 這里是分配7個(gè)int單元而不是7bytes
*p4 = 9;
allocator<int>().deallocate((int *)p4,7);// 7應(yīng)該與上文匹配

1、 new/delete表達(dá)式

new表達(dá)式的內(nèi)部實(shí)現(xiàn)是由三個(gè)步驟組成的，首先調(diào)用operator new分配一定的字節(jié)數(shù)的內(nèi)存，此時(shí)得到的內(nèi)存指針是void*類型的，將之用static_cast轉(zhuǎn)換成需要的class類型，然后調(diào)用class的構(gòu)造函數(shù)完成初始化。

Complex *pc;
try {
   void* mem = operator new(sizeof(Complex)); // 分配內(nèi)存
   pc = static_cast<Complex*>(mem);    // cast 轉(zhuǎn)型 以符合對(duì)應(yīng)的類型，這里對(duì)應(yīng)為Complex*
   pc->Complex::Complex(1,2); // construct
   // 注意：只有編譯器才可以像上面那樣直接呼叫constructor 欲直接調(diào)用constructor可通用placement new: new(p) Complex(1,2);
}
catch(std::bad_alloc) {
   // 若allocation失敗就不執(zhí)行constructor
}

從上面的new的實(shí)現(xiàn)中，不難發(fā)現(xiàn)，new返回的是對(duì)象指針，失敗是拋出bad_alloc異常，我們應(yīng)該通過是否拋出異常來判斷new執(zhí)行狀況，而不是像malloc一樣通過判斷返回值是否為nullptr。

對(duì)于delete，其具體操作與new相反，先調(diào)用對(duì)象的析構(gòu)函數(shù)，再釋放內(nèi)存。

// delete pc;
pc->~Complex();  //先析構(gòu)
operator delete(pc);   //然后釋放內(nèi)存

array new和array delete可以獲取一組對(duì)象，new的時(shí)候不能同時(shí)初始化，因此通常結(jié)合placement new來創(chuàng)建對(duì)象。

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

A* buf = new A[size]; // 調(diào)用三次默認(rèn)構(gòu)造函數(shù)A():id(0)
A* tmp = buf;
// placement new指定位置new
for(int i = 0; i<size; i++)
    new(tmp++) A(i);  //調(diào)用A(int i): id(i)自定義初始化
delete []buf; // 調(diào)用三次~A()

new array的構(gòu)造是從0到size-1依次構(gòu)造，析構(gòu)的時(shí)候恰恰相反（但這不重要）。new array返回的指針指向第0個(gè)對(duì)象的起始位置。

數(shù)組的new必須和數(shù)組的delete聯(lián)合使用，否則可能發(fā)生內(nèi)存泄漏：若只使用delete而非delete [] ，則只會(huì)將分配的size塊內(nèi)存空間釋放，但是不會(huì)調(diào)用對(duì)象的析構(gòu)函數(shù)（可能是因?yàn)榇颂帉ize塊對(duì)象視為一個(gè)對(duì)象之后，找不到合適的析構(gòu)函數(shù)），沒有析構(gòu)就釋放內(nèi)存是很不優(yōu)雅的，如果對(duì)象內(nèi)部還使用了new指向其他空間，那么這部分空間不會(huì)被釋放。如果new array分配的是一些析構(gòu)函數(shù)沒有意義的對(duì)象

比如：

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

那么是完全沒有問題的，delete等價(jià)于delete[] 。

附圖：聲明了3個(gè)對(duì)象的時(shí)候的內(nèi)存分布，其中cookie保存著數(shù) 組大小等信息。

2、new/delete重載

C++ new的調(diào)用鏈?zhǔn)菆D中的2，operator new將在全局環(huán)境下尋找匹配的函數(shù)。如果要重構(gòu)，則最好在此處將其轉(zhuǎn)為調(diào)用類內(nèi)自定義的Foo::operator new，在Foo::operator new中再調(diào)用::operator new。已經(jīng)定義了重載之后，也可以通過直接調(diào)用::operator new來繞過重載。重載的原則是，盡量在高層、部分可見的局部進(jìn)行重載，使影響盡可能小而且可控。繪制函數(shù)調(diào)用鏈可以很好地幫助決定重載層次。除了new之外，new array等也可以重載。

3、類內(nèi)自定義allocator（per-class allocator）

本節(jié)介紹的是一個(gè)類內(nèi)借助內(nèi)存池的內(nèi)存管理。雖然malloc不慢，但減少malloc調(diào)用次數(shù)總是好的；此外，一次malloc得到的內(nèi)存塊前總是帶有一個(gè)cookie，它占有8個(gè)字節(jié)?；谝陨蟽蓚€(gè)原因，從時(shí)間和空間的角度看，建立內(nèi)存池都是有必要的。

思考：當(dāng)每次alloc的時(shí)候都alloc固定大小的一大塊的時(shí)候，應(yīng)該更難以產(chǎn)生外部碎片（雖然可能更容易產(chǎn)生內(nèi)部碎片），而且固定大小對(duì)于OS的高級(jí)分配器來說是十分友好的。

這里直接看per-class allocator3。

• embedded pointer和類型轉(zhuǎn)換
• 鏈表管理的內(nèi)存池
• 抽象的思想
• if判斷將值放在變量前面,這樣可以避免少寫等號(hào),編譯器不報(bào)錯(cuò)問題，例如 if(1!=p){} 。
  

#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){
    // 從內(nèi)存池分配一個(gè)obj對(duì)象大小的內(nèi)存
    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){
    // 插入到內(nèi)存池
    (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; // 靜態(tài)成員變量一定要在類聲明之外定義

以下討論GNU編譯器中的內(nèi)存管理機(jī)制。

allocator是普通的分配器，它通過operator new和operator delete調(diào)用malloc和free，沒有特殊的設(shè)計(jì)。

G4.9的__pool_alloc（相當(dāng)于G2.9的std::alloc）是在容器中使用的分配器，是利用上了內(nèi)存池的分配器。std::alloc使用一個(gè)16個(gè)寫代指針頭的數(shù)組來管理內(nèi)存鏈表，數(shù)組的不同元素管理不同大小的區(qū)塊，每種區(qū)塊大小相差8個(gè)字節(jié)。內(nèi)存首先由malloc分配到戰(zhàn)備池pool中，再從戰(zhàn)備池挖適當(dāng)?shù)目臻g到鏈表。假設(shè)用戶需要32字節(jié)的內(nèi)存，std::alloc首先申請(qǐng)一塊區(qū)間，大小為32*20*2，用一條鏈表管理，然后讓數(shù)組的#3指針管理這條鏈表，接著將其中一個(gè)單元（32字節(jié)）分給用戶。這32*20*2中，一半是給用戶的，后一半預(yù)留在戰(zhàn)備池中，如果此時(shí)用戶需要一個(gè)64字節(jié)的空間，那么剩下的一半將變成64*10（通常是申請(qǐng)64*20），由另一個(gè)鏈表指針指向這里，然后將其中64字節(jié)分配給用戶，而不用再一次構(gòu)建鏈表和申請(qǐng)空間。鏈表數(shù)組維護(hù)的鏈表最大塊是128字節(jié)，如果申請(qǐng)超過了這個(gè)大小，那么直接調(diào)用malloc給用戶分配，這樣每一塊都會(huì)帶上cookie頭和尾。

• 戰(zhàn)備池，池中內(nèi)存沒有固定塊大小
• 多級(jí)大小內(nèi)存池鏈表
• 兩級(jí)分配器：超過最大大小直接使用malloc分配

G2.9中的一級(jí)配置器主要是對(duì)malloc和free進(jìn)行了一些封裝，當(dāng)申請(qǐng)的內(nèi)存較大的時(shí)候，二級(jí)分配器將直接調(diào)用一級(jí)分配器。一級(jí)分配器在G4.9中已經(jīng)棄用。此處不再過多闡述。

二級(jí)配置器執(zhí)行分配器的主要功能。流程圖和部分源碼如下。

static const int __ALLGN = 8; // 上調(diào)邊界
static const int __MAX_BYTES = 8; // 分配Chunk的上限
static const int __NFREELISTS = __MAX_BYTES/__ALLGN; // 鏈表的條數(shù)

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指針，老規(guī)矩用了ebedded pointer
  }
  static obj* volatile free_list[__NFREELISTS]; // 多級(jí)大小內(nèi)存池
  static size_t FREELIST_INDEX(size_t bytes){ // 根據(jù)大小確定鏈表index
   return ((bytes+ALLGN-1)/__ALLGN-1);
  }
  static void *refill(size_t size);
  static char* chunk_alloc(size_t size, int &nobjs);
  
  // 戰(zhàn)備池
  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改用第一級(jí)分配器
    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)); // 對(duì)此鏈表充值
    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改用第一級(jí)分配器
    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中的空間不連續(xù)還能直接分配和相加嗎？A：虛擬地址是連續(xù)的】
        return(result); 
    }else if(bytees_left >= size) {  //pool空間只滿足一塊以上
        
        nobjs = bytees_left / size;   //改變需求個(gè)數(shù)
        total_bytes  = size * nobjs;  //改變需求總量   pass-by-value會(huì)改變參數(shù)
        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);
        //處理碎片(將其掛到相應(yīng)的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) {  //如果當(dāng)前的chunk分配失敗，則向上繼續(xù)找相鄰的chunk繼續(xù)分配
            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有可用區(qū)塊
                    *my_free_list = p->free_list_link; 
                    start_free  = (char*)p;
                    end_free = start_free + i; 
                    return (chunk_alloc(size, nobjs));   //結(jié)果再試一次
                }
            }
            end_free = 0;
            start_free = (char*)malloc_alloc::allocate(bytes_to_get); 
        }
 
        //至此，表示已經(jīng)從system free-store成功取得很多memory
        heap_size += bytes_to_get;
        end_free = start_free + bytes_to_get;
        return (chunk_alloc(size, nobjs));   //戰(zhàn)備池有內(nèi)存了，所以遞歸重新處理分配邏輯
    }
}
 
//靜態(tài)定義(分配內(nèi)存)
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為第二級(jí)分配器
typedef  __default_alloc_template<false, 0> alloc;

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

二、多線程內(nèi)存分配器

__pool_alloc：For thread-enabled configurations, the pool is locked with a single big lock.

mt_alloc：使用了全局鏈表，分配到線程時(shí)移動(dòng)到線程專享鏈表，在此過程中，只對(duì)鏈表的一個(gè)bin加鎖。exponentially-increasing allocations。

tips:盡量減小鎖的粒度

1、malloc/free

malloc/free是 libc實(shí)現(xiàn)的庫函數(shù)，主要實(shí)現(xiàn)了一套內(nèi)存管理機(jī)制，當(dāng)其管理的內(nèi)存不夠時(shí)，通過brk/mmap等系統(tǒng)調(diào)用向內(nèi)核申請(qǐng)進(jìn)程的虛擬地址區(qū)間，如果其維護(hù)的內(nèi)存能滿足malloc調(diào)用，則直接返回，free時(shí)會(huì)將地址塊返回空閑鏈表。

malloc（size） 的時(shí)候，這個(gè)函數(shù)會(huì)多分配一塊空間，用于保存size變量，free的時(shí)候，直接通過指針前移一定大小，就可以獲取malloc時(shí)保存的size變量，從而free只需要一個(gè)指針作為參數(shù)就可以了calloc 庫函數(shù)相當(dāng)于 malloc + memset(0)

malloc和free碎片化嚴(yán)重（內(nèi)存站崗），在高并發(fā)下性能低下。除了libc自帶的動(dòng)態(tài)內(nèi)存管理庫malloc, 有時(shí)候還可以使用其他的內(nèi)存管理庫替換，比如使用google實(shí)現(xiàn)的tcmalloc ,只需要編譯進(jìn)程時(shí)鏈接上 tcmalloc的靜態(tài)庫并包含響應(yīng)頭文件，就可以透明地使用tcmalloc 了，與libc 的malloc相比， tcmalloc 在內(nèi)存管理上有很多改進(jìn)，效率和安全性更好。

2、brk和mmap

在Linux下，glibc 的malloc提供了下面兩種動(dòng)態(tài)內(nèi)存管理的方法：堆內(nèi)存分配和mmap的內(nèi)存分配，此兩種分配方法都是通過相應(yīng)的Linux 系統(tǒng)調(diào)用來進(jìn)行動(dòng)態(tài)內(nèi)存管理的。具體使用哪一種方式分配，根據(jù)glibc的實(shí)現(xiàn)，主要取決于所需分配內(nèi)存的大小。一般情況中，應(yīng)用層面的內(nèi)存從進(jìn)程堆中分配，當(dāng)進(jìn)程堆大小不夠時(shí)，可以通過系統(tǒng)調(diào)用brk來改變堆的大小，但是在以下情況，一般由mmap系統(tǒng)調(diào)用來實(shí)現(xiàn)應(yīng)用層面的內(nèi)存分配：A、應(yīng)用需要分配大于1M的內(nèi)存，B、在沒有連續(xù)的內(nèi)存空間能滿足應(yīng)用所需大小的內(nèi)存時(shí)。

(1)、調(diào)用brk實(shí)現(xiàn)進(jìn)程里堆內(nèi)存分配

在glibc中，當(dāng)進(jìn)程所需要的內(nèi)存較小時(shí)，該內(nèi)存會(huì)從進(jìn)程的堆中分配，但是堆分配出來的內(nèi)存空間，系統(tǒng)一般不會(huì)回收，只有當(dāng)進(jìn)程的堆大小到達(dá)最大限額時(shí)或者沒有足夠連續(xù)大小的空間來為進(jìn)程繼續(xù)分配所需內(nèi)存時(shí)，才會(huì)回收不用的堆內(nèi)存。在這種方式下，glibc會(huì)為進(jìn)程堆維護(hù)一些固定大小的內(nèi)存池以減少內(nèi)存碎片。

(2)、使用mmap的內(nèi)存分配（堆和棧中間，稱為“文件映射區(qū)域”的地方）

在glibc中，一般在比較大的內(nèi)存分配時(shí)使用mmap系統(tǒng)調(diào)用，它以頁為單位來分配內(nèi)存的（在Linux中，一般一頁大小定義為4K），這不可避免會(huì)帶來內(nèi)存浪費(fèi)，但是當(dāng)進(jìn)程調(diào)用free釋放所分配的內(nèi)存時(shí)，glibc會(huì)立即調(diào)用unmmap，把所分配的內(nèi)存空間釋放回系統(tǒng)。

注意： 這里我們討論的都是虛擬內(nèi)存的分配（即應(yīng)用層面上的內(nèi)存分配），主要由glibc來實(shí)現(xiàn)，它與內(nèi)核中實(shí)際物理內(nèi)存的分配是不同的層面，進(jìn)程所分配到的虛擬內(nèi)存可能沒有對(duì)應(yīng)的物理內(nèi)存。如果所分配的虛擬內(nèi)存沒有對(duì)應(yīng)的物理內(nèi)存時(shí)，操作系統(tǒng)會(huì)利用缺頁機(jī)制來為進(jìn)程分配實(shí)際的物理內(nèi)存。

默認(rèn)情況下，malloc函數(shù)分配內(nèi)存，如果請(qǐng)求內(nèi)存大于128K（可由M_MMAP_THRESHOLD選項(xiàng)調(diào)節(jié)），那就不是去推_edata指針了，而是利用mmap系統(tǒng)調(diào)用，從堆和棧的中間分配一塊虛擬內(nèi)存。

這樣子做主要是因?yàn)閎rk分配的內(nèi)存需要等到高地址內(nèi)存釋放以后才能釋放（例如，在B釋放之前，A是不可能釋放的，因?yàn)橹挥幸粋€(gè)_edata 指針，這就是內(nèi)存碎片產(chǎn)生的原因）（圖2緊縮），而mmap分配的內(nèi)存可以單獨(dú)釋放。

malloc當(dāng)最高地址空間的空閑內(nèi)存超過128K（可由M_TRIM_THRESHOLD選項(xiàng)調(diào)節(jié)）時(shí)，執(zhí)行內(nèi)存緊縮操作（trim）

缺頁中斷：

• 陷入內(nèi)核態(tài)
• 檢查要訪問的虛擬地址是否合法
• 查找/分配一個(gè)物理頁[......]（buddy+slab）
• 填充物理頁內(nèi)容（讀取磁盤，或者直接置0，或者什么都不做）
• 建立映射關(guān)系（虛擬地址到物理地址的映射關(guān)系）
• 重復(fù)執(zhí)行發(fā)生缺頁中斷的那條指令

三、補(bǔ)充知識(shí)

1、內(nèi)存泄漏

內(nèi)存泄露是很隱蔽的錯(cuò)誤，通常少量的內(nèi)存泄露不會(huì)造成什么問題，大量的內(nèi)存泄露可能會(huì)有“out of memory（OOM）”錯(cuò)誤。

內(nèi)存泄露的檢測(cè)通常借助于內(nèi)存分析工具；（ valgrind 或 purify ）

一般如果是簡(jiǎn)單的 new 之后，沒有 delete，這種泄漏最容易發(fā)現(xiàn)。真實(shí)場(chǎng)景可能比這復(fù)雜得多。有時(shí)候定位了相應(yīng)的函數(shù)，但是代碼比較復(fù)雜，還是找不到泄漏點(diǎn)，可以參考如下幾個(gè)地方：

map：c++的map，在下標(biāo)訪問的時(shí)候自動(dòng)構(gòu)造 value 對(duì)象，可能造成 map 無限增長(zhǎng)；

unordered_set: 在插入大量的元素之后，再刪除，內(nèi)存占用保持不變，需要手動(dòng) rehash；

容器的 size 很大：通過 gcore -o xxx pidof yyy ，然后 gdb 去查看有嫌疑的容器的長(zhǎng)度；

如果容器的 size 正常，但是還是有泄漏，可能跟智能指針有關(guān)，例如 shared ptr，被泄漏；

2、malloc/free和new/delete的比較

3、RAII規(guī)則

RAII是指C++語言中的一個(gè)慣用法（idiom），它是“Resource Acquisition Is Initialization”的首字母縮寫。中文可將其翻譯為“資源獲取就是初始化”。

需要?jiǎng)討B(tài)獲取和釋放的都可以稱為“資源”；

獲取資源和釋放資源要對(duì)應(yīng)，這里就會(huì)面臨麻煩：釋放的不徹底將會(huì)導(dǎo)致memory leak，致使程序臃腫、出錯(cuò)等。

看到這里自然而然的可以想到C++中的一對(duì)特殊函數(shù)，構(gòu)造函數(shù)和析構(gòu)函數(shù)。在構(gòu)造函數(shù)中申請(qǐng)資源，以及在析構(gòu)函數(shù)中釋放資源。

類是C++中的主要抽象工具，那么就將資源抽象為類，用局部對(duì)象來表示資源，把管理資源的任務(wù)轉(zhuǎn)化為管理局部對(duì)象的任務(wù)。這就是RAII慣用法，RAII有效地實(shí)現(xiàn)了C++資源管理的自動(dòng)化。

到此這篇關(guān)于C++內(nèi)存管理詳細(xì)解析的文章就介紹到這了,更多相關(guān)C++內(nèi)存管理內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！