C語言與C++的內存管理區別 以及 new與malloc的10點區別

喵哥最近面試的時候遇到這麼一道題：C語言與C++的內存管理區別？喵哥當時回答的很草率，屬實沒有深入瞭解過，也沒有怎麼在意。今天把這道題總結一下。

內存的分區

在C/C++中，內存分爲5個區：棧、堆、自由存儲區（C++纔有）、全局/靜態存儲區和常量存儲區。

棧：就是那些由編譯器在需要的時候分配，在不需要的時候自動清楚的變量的存儲區，裏面的變量通常是局部變量、函數參數等。

堆： 操作系統層面的術語。就是那些由malloc等分配的內存塊，用free來結束自己的生命的。

自由存儲區：C++層面上的術語，就是那些由new分配的內存塊，他們的釋放編譯器不去管，由我們的應用程序去控制，一般一個new就要對應一個delete。如果程序員沒有釋放掉，那麼在程序結束後，操作系統會自動回收。new的申請是調用的malloc，自由存儲區就和堆類似，但不等價。存儲對象可以在不立即初始化的情況下分配內存，並且可以在不立即釋放內存的情況下銷燬它們。

全局/靜態存儲區：全局變量和靜態變量被分配到同一塊內存中，在以前的C語言中，全局變量又分爲初始化的和未初始化的，在C++裏面沒有這個區分了，他們共同佔用同一塊內存區。

常量存儲區：這是一塊比較特殊的存儲區，他們裏面存放的是常量，不允許修改，如字符串"abc"。

綜合上述，C語言中全局變量會有初始化和未初始化的區分，C++沒有。同樣C++中有自由存儲區的說法，而C語言沒有。

若從人的角度看，內存還可以這麼分：

棧區（stack）：— 由編譯器自動分配釋放 ，存放函數的參數值，局部變量的值等。其操作方式類似於數據結構中的棧。

堆區（heap） — 一般由程序員分配釋放， 若程序員不釋放，程序結束時可能由OS回收 。注意它與數據結構中的堆是兩回事，分配方式倒是類似於鏈表，呵呵。

全局區（靜態區）（static）—，全局變量和靜態變量的存儲是放在一塊的，初始化的全局變量和靜態變量在一塊區域， 未初始化的全局變量和未初始化的靜態變量在相鄰的另一塊區域。 - 程序結束後由系統釋放。

文字常量區—常量字符串就是放在這裏的。 程序結束後由系統釋放

程序代碼區—存放函數體的二進制代碼。

程序被操作系統加載到內存的時候，所有的可執行代碼（程序代碼指令、常量字符串等）都加載到代碼區，這塊內存在程序運行期間是不變的。代碼區是平行的，裏面裝的就是一堆指令，在程序運行期間是不能改變的。函數也是代碼的一部分，故函數都被放在代碼區，包括main函數。

注意："int a = 0;"語句可拆分成"int a;"和"a = 0"，定義變量a的"int a;"語句並不是代碼，它在程序編譯時就執行了，並沒有放到代碼區，放到代碼區的只有"a = 0"這句。

//main.cpp 
int a = 0; 全局初始化區 
char *p1; 全局未初始化區 
main() 
{ 
int b; 棧 
char s[] = "abc"; 棧 
char *p2; 棧 
char *p3 = "123456"; 123456\0在常量區，p3在棧上。 
static int c =0； 全局（靜態）初始化區 
p1 = (char *)malloc(10); 
p2 = (char *)malloc(20); 
分配得來得10和20字節的區域就在堆區。 
strcpy(p1, "123456"); 123456\0放在常量區，編譯器可能會將它與p3所指向的"123456"優化成一個地方。
}  

---

以上參考：

https://blog.csdn.net/u011236602/article/details/82686599

---

C語言中採用malloc(),calloc(),realloc()來進行內存分配,而釋放內存的函數爲free()
1.malloc函數

函數爲void *malloc(unsigned int size)
在內存的動態存儲區中分配一塊長度爲"size" 字節的連續區域。函數的返回值爲該區域的首地址。 “類型說明符”表示把該區域用於何種數據類型。(類型說明符)*表示把返回值強制轉換爲該類型指針。“size”是一個無符號數。例如： pc=(char *) malloc (100); 表示分配100個字節的內存空間，並強制轉換爲字符數組類型，函數的返回值爲指向該字符數組的指針， 把該指針賦予指針變量pc。若size超出可用空間，則返回空指針值NULL。

2.calloc 函數

函數爲void *calloc(unsigned int num, unsigned int size)

按所給數據個數和每個數據所佔字節數開闢存儲空間。其中num爲數據個數，size爲每個數據所佔字節數，故開闢的總字節數爲numsize。函數返回該存儲區的起始地址。calloc函數與malloc 函數的區別僅在於一次可以分配n塊區域。例如： ps=(struct stu) calloc(2,sizeof (struct stu)); 其中的sizeof(struct stu)是求stu的結構長度。因此該語句的意思是：按stu的長度分配2塊連續區域，強制轉換爲stu類型，並把其首地址賦予指針變量ps。

3． realloc函數：

函數爲void *realloc(void *ptr, unsigned int size)

ptr指向的要改變的空間地址，如果size大小的連續的空間，那麼就返回ptr，如果沒有size大小的空間，那麼就需要重新申請新的連續空間，把之前空間的數據拷貝到新的空間，釋放以前的空間的數據，返回新的地址。

動態申請的內存空間要進行手動用free()函數釋放

4． free函數：

函數原型爲void free(void *ptr)

將以前開闢的某內存空間釋放。函數原型爲 void free(void *ptr)其中ptr爲存放待釋放空間起始地址的指針變量，函數無返回值。應注意：ptr所指向的空間必須是前述函數所開闢的。例如free((void *)p1);將上例開闢的16個字節釋放。可簡寫爲free(p1);由系統自動進行類型轉換。

 

C++語言中用new和delete運算符來動態申請和釋放內存。

---

參考：https://blog.csdn.net/everestrs/article/details/83314811

---

new與malloc的10點區別

1. 申請的內存所在位置

new操作符從自由存儲區（free store）上爲對象動態分配內存空間，而malloc函數從堆上動態分配內存。自由存儲區是C++基於new操作符的一個抽象概念，凡是通過new操作符進行內存申請，該內存即爲自由存儲區。而堆是操作系統中的術語，是操作系統所維護的一塊特殊內存，用於程序的內存動態分配，C語言使用malloc從堆上分配內存，使用free釋放已分配的對應內存。

那麼自由存儲區是否能夠是堆（問題等價於new是否能在堆上動態分配內存），這取決於operator new 的實現細節。自由存儲區不僅可以是堆，還可以是靜態存儲區，這都看operator new在哪裏爲對象分配內存。

特別的，new甚至可以不爲對象分配內存！定位new的功能可以辦到這一點：

new (place_address) type

place_address爲一個指針，代表一塊內存的地址。當使用上面這種僅以一個地址調用new操作符時，new操作符調用特殊的operator new，也就是下面這個版本：

void * operator new (size_t,void *) //不允許重定義這個版本的operator new

這個operator new不分配任何的內存，它只是簡單地返回指針實參，然後右new表達式負責在place_address指定的地址進行對象的初始化工作。

2.返回類型安全性

new操作符內存分配成功時，返回的是對象類型的指針，類型嚴格與對象匹配，無須進行類型轉換，故new是符合類型安全性的操作符。而malloc內存分配成功則是返回void * ，需要通過強制類型轉換將void*指針轉換成我們需要的類型。
類型安全很大程度上可以等價於內存安全，類型安全的代碼不會試圖方法自己沒被授權的內存區域。關於C++的類型安全性可說的又有很多了。

3.內存分配失敗時的返回值

new內存分配失敗時，會拋出bac_alloc異常，它不會返回NULL；malloc分配內存失敗時返回NULL。
在使用C語言時，我們習慣在malloc分配內存後判斷分配是否成功：

int *a  = (int *)malloc ( sizeof (int ));
if(NULL == a)
{
    ...
}
else 
{
    ...
}

從C語言走入C++陣營的新手可能會把這個習慣帶入C++：

int * a = new int();
if(NULL == a)
{
    ...
}
else
{   
    ...
}

實際上這樣做一點意義也沒有，因爲new根本不會返回NULL，而且程序能夠執行到if語句已經說明內存分配成功了，如果失敗早就拋異常了。正確的做法應該是使用異常機制：

try
{
    int *a = new int();
}
catch (bad_alloc)
{
    ...
}

如果你想順便了解下異常基礎，可以看http://www.cnblogs.com/QG-whz/p/5136883.htmlC++ 異常機制分析。

4.是否需要指定內存大小

使用new操作符申請內存分配時無須指定內存塊的大小，編譯器會根據類型信息自行計算，而malloc則需要顯式地指出所需內存的尺寸。

class A{...}
A * ptr = new A;
A * ptr = (A *)malloc(sizeof(A)); //需要顯式指定所需內存大小sizeof(A);

當然了，我這裏使用malloc來爲我們自定義類型分配內存是不怎麼合適的，請看下一條。

5.是否調用構造函數/析構函數

使用new操作符來分配對象內存時會經歷三個步驟：

• 第一步：調用operator new 函數（對於數組是operator new[]）分配一塊足夠大的，原始的，未命名的內存空間以便存儲特定類型的對象。
• 第二步：編譯器運行相應的構造函數以構造對象，併爲其傳入初值。
• 第三部：對象構造完成後，返回一個指向該對象的指針。

使用delete操作符來釋放對象內存時會經歷兩個步驟：

• 第一步：調用對象的析構函數。
• 第二步：編譯器調用operator delete(或operator delete[])函數釋放內存空間。

總之來說，new/delete會調用對象的構造函數/析構函數以完成對象的構造/析構。而malloc則不會。如果你不嫌囉嗦可以看下我的例子：

class A
{
public:
    A() :a(1), b(1.11){}
private:
    int a;
    double b;
};
int main()
{
    A * ptr = (A*)malloc(sizeof(A));
    return 0;
}

在return處設置斷點，觀看ptr所指內存的內容：

可以看出A的默認構造函數並沒有被調用，因爲數據成員a,b的值並沒有得到初始化，這也是上面我爲什麼說使用malloc/free來處理C++的自定義類型不合適，其實不止自定義類型，標準庫中凡是需要構造/析構的類型通通不合適。

而使用new來分配對象時：

int main()
{
    A * ptr = new A;
}

查看程序生成的彙編代碼可以發現，A的默認構造函數被調用了：

6.對數組的處理

C++提供了new[]與delete[]來專門處理數組類型:

A * ptr = new A[10];//分配10個A對象

使用new[]分配的內存必須使用delete[]進行釋放：

delete [] ptr;

new對數組的支持體現在它會分別調用構造函數函數初始化每一個數組元素，釋放對象時爲每個對象調用析構函數。注意delete[]要與new[]配套使用，不然會找出數組對象部分釋放的現象，造成內存泄漏。

至於malloc，它並知道你在這塊內存上要放的數組還是啥別的東西，反正它就給你一塊原始的內存，在給你個內存的地址就完事。所以如果要動態分配一個數組的內存，還需要我們手動自定數組的大小：

int * ptr = (int *) malloc( sizeof(int) );//分配一個10個int元素的數組

7.new與malloc是否可以相互調用

operator new /operator delete的實現可以基於malloc，而malloc的實現不可以去調用new。下面是編寫operator new /operator delete 的一種簡單方式，其他版本也與之類似：

void * operator new (sieze_t size)
{
    if(void * mem = malloc(size)
        return mem;
    else
        throw bad_alloc();
}
void operator delete(void *mem) noexcept
{
    free(mem);
}

8.是否可以被重載

opeartor new /operator delete可以被重載。標準庫是定義了operator new函數和operator delete函數的8個重載版本：

//這些版本可能拋出異常
void * operator new(size_t);
void * operator new[](size_t);
void * operator delete (void * )noexcept;
void * operator delete[](void *0）noexcept;
//這些版本承諾不拋出異常
void * operator new(size_t ,nothrow_t&) noexcept;
void * operator new[](size_t, nothrow_t& );
void * operator delete (void *,nothrow_t& )noexcept;
void * operator delete[](void *0,nothrow_t& ）noexcept;

我們可以自定義上面函數版本中的任意一個，前提是自定義版本必須位於全局作用域或者類作用域中。太細節的東西不在這裏講述，總之，我們知道我們有足夠的自由去重載operator new /operator delete ,以決定我們的new與delete如何爲對象分配內存，如何回收對象。

而malloc/free並不允許重載。

9. 能夠直觀地重新分配內存

使用malloc分配的內存後，如果在使用過程中發現內存不足，可以使用realloc函數進行內存重新分配實現內存的擴充。realloc先判斷當前的指針所指內存是否有足夠的連續空間，如果有，原地擴大可分配的內存地址，並且返回原來的地址指針；如果空間不夠，先按照新指定的大小分配空間，將原有數據從頭到尾拷貝到新分配的內存區域，而後釋放原來的內存區域。

new沒有這樣直觀的配套設施來擴充內存。

10. 客戶處理內存分配不足

在operator new拋出異常以反映一個未獲得滿足的需求之前，它會先調用一個用戶指定的錯誤處理函數，這就是new-handler。new_handler是一個指針類型：

namespace std
{
    typedef void (*new_handler)();
}

指向了一個沒有參數沒有返回值的函數,即爲錯誤處理函數。爲了指定錯誤處理函數，客戶需要調用set_new_handler，這是一個聲明於的一個標準庫函數:

namespace std
{
    new_handler set_new_handler(new_handler p ) throw();
}

set_new_handler的參數爲new_handler指針，指向了operator new 無法分配足夠內存時該調用的函數。其返回值也是個指針，指向set_new_handler被調用前正在執行（但馬上就要發生替換）的那個new_handler函數。

對於malloc，客戶並不能夠去編程決定內存不足以分配時要幹什麼事，只能看着malloc返回NULL。

總結

將上面所述的10點差別整理成表格：

特徵	new/delete	malloc/free
分配內存的位置	自由存儲區	堆
內存分配失敗返回值	完整類型指針	void*
內存分配失敗返回值	默認拋出異常	返回NULL
分配內存的大小	由編譯器根據類型計算得出	必須顯式指定字節數
處理數組	有處理數組的new版本new[]	需要用戶計算數組的大小後進行內存分配
已分配內存的擴充	無法直觀地處理	使用realloc簡單完成
是否相互調用	可以，看具體的operator new/delete實現	不可調用new
分配內存時內存不足	客戶能夠指定處理函數或重新制定分配器	無法通過用戶代碼進行處理
函數重載	允許	不允許
構造函數與析構函數	調用	不調用

malloc給你的就好像一塊原始的土地，你要種什麼需要自己在土地上來播種

而new幫你劃好了田地的分塊（數組），幫你播了種（構造函數），還提供其他的設施給你使用:

當然，malloc並不是說比不上new，它們各自有適用的地方。在C++這種偏重OOP的語言，使用new/delete自然是更合適的。

---

以上參考了：https://www.cnblogs.com/ywliao/articles/8116622.html

---