New與malloc的區(qū)別

?1,malloc與free是C++/C語言的標準庫函數(shù)，new/delete是C++的運算符。它們都可用于申請動態(tài)內存和釋放內存。

?2,?對于非內部數(shù)據(jù)類型的對象而言，光用maloc/free無法滿足動態(tài)對象的要求。對象在創(chuàng)建的同時要自動執(zhí)行構造函數(shù)，對象在消亡之前要自動執(zhí)行析構函數(shù)。由于malloc/free是庫函數(shù)而不是運算符，不在編譯器控制權限之內，不能夠把執(zhí)行構造函數(shù)和析構函數(shù)的任務強加于malloc/free。

?3,因此C++語言需要一個能完成動態(tài)內存分配和初始化工作的運算符new，以一個能完成清理與釋放內存工作的運算符delete。注意new/delete不是庫函數(shù)。

?4,C++程序經常要調用C函數(shù)，而C程序只能用malloc/free管理動態(tài)內存?new?是個操作符,和什么"+","-","="...有一樣的地位?簡單的說:?malloc,free是c的函數(shù),new,delete是c++的運算符?此外,new是強制類型的,malloc不是,需要類型轉換?當然還有很多不同?new?可以調用構造函數(shù)在聲明的時候初始化?malloc只是分配空間,需要在其他地方初始化?而delete不僅會釋放空間,在釋放前會調用析構函數(shù)?而且malloc需要指定分配空間大小,?而new是自動計算的

New與malloc的區(qū)別集錦

1、new 是c++中的操作符，malloc是c 中的一個函數(shù)

2、new 不止是分配內存，而且會調用類的構造函數(shù)，同理delete會調用類的析構函數(shù)，而malloc則只分配內存，不會進行初始化類成員的工作，同樣free 也不會調用析構函數(shù)

3、內存泄漏對于malloc或者new都可以檢查出來的，區(qū)別在于new可以指明是那個文件的那一行，而malloc沒有這些信息。

4、new 和 malloc效率比較

new 有三個字母, malloc有六個字母

new可以認為是malloc加構造函數(shù)的執(zhí)行。

new出來的指針是直接帶類型信息的。

而malloc返回的都是void指針。

一：new delete 是運算符，malloc,free是函數(shù)

malloc與free是C++/C語言的標準庫函數(shù)，new/delete是C++的運算符。它們 都可用于申請動態(tài)內存和釋放內存。

對于非內部數(shù)據(jù)類型的對象而言，光用maloc/free無法滿足動態(tài)對象的要求。對象在創(chuàng)建的同時 要自動執(zhí)行構造函數(shù)，對象在消亡之前要自動執(zhí)行析構函數(shù)。由于malloc/free是庫函數(shù)而不是運算符，不在編譯器控制權限之內，不能夠把執(zhí)行構造函 數(shù)和析構函數(shù)的任務強加于malloc/free。

因此C++語言需要一個能完成動態(tài)內存分配和初始化工作的運算符new，以及一個能完成清理與釋放內 存工作的運算符delete。注意new/delete不是庫函數(shù)。

我們先看一看malloc/free和new/delete如何實現(xiàn)對象的動態(tài)內存管理，見示例。

?

class Obj

{

public :

??????????Obj(void){ cout < < “Initialization” << endl; }

~Obj(void){ cout < < “Destroy” << endl; }

void??????Initialize(void){ cout < < “Initialization” << endl; }

void??????Destroy(void){ cout < < “Destroy” << endl; }

};

?

void UseMallocFree(void)

{

??????Obj????*a = (obj *)malloc(sizeof(obj));?????// 申請動態(tài)內存

??????a->Initialize();??????????????????????????// 初始化

??????//…

??????a->Destroy();?????// 清除工作

??????free(a);??????????// 釋放內存

}

?

void UseNewDelete(void)

{

??????Obj????*a = new Obj;????// 申請動態(tài)內存并且初始化

??????//…

??????delete a;?????????????// 清除并且釋放內存

}

示例用malloc/free和new/delete如何實現(xiàn)對象的動態(tài)內存管理

類Obj的函數(shù)Initialize模擬了構造函數(shù)的功能，函數(shù)Destroy模擬了析構函數(shù)的功 能。函數(shù)UseMallocFree中，由于malloc/free不能執(zhí)行構造函數(shù)與析構函數(shù)，必須調用成員函數(shù)Initialize和Destroy 來完成初始化與清除工作。函數(shù)UseNewDelete則簡單得多。

所以我們不要企圖用malloc/free來完成動態(tài)對象的內存管理，應該用new/delete。 由于內部數(shù)據(jù)類型的“對象”沒有構造與析構的過程，對它們而言malloc/free和new/delete是等價的。

既然new/delete的功能完全覆蓋了malloc/free，為什么C++不把malloc /free淘汰出局呢？這是因為C++程序經常要調用C函數(shù)，而C程序只能用malloc/free管理動態(tài)內存。

如果用free釋放“new創(chuàng)建的動態(tài)對象”，那么該對象因無法執(zhí)行析構函數(shù)而可能導致程序出錯。如 果用delete釋放“malloc申請的動態(tài)內存”，理論上講程序不會出錯，但是該程序的可讀性很差。所以new/delete 必須配對使用，malloc/free也一樣。

二：new delete在實現(xiàn)上其實調用了malloc,free函數(shù)。

三：new operator除了分配內存，還要調用構造函數(shù)。

malloc函數(shù)只是負責分配內存。

?

///////////////////////////////////////

new 一維數(shù)組

XXX *arr;
int len; // 動態(tài)確定該長度值

arr = new XXX[len]; // 動態(tài)分配，也可以使用 malloc
...
delete[] arr; //不要忘記釋放

new 多維數(shù)組

正確的做法是先聲明一個n維數(shù)組，每個單元是指向char的指針，再分別對每個單元分配內存.代碼如下

char **array=new char*[n];
for(int i=0;i array[i]=new char[m];

注意：上面代碼在釋放分配的內存時要特別注意。因為這是“深度內存分配”，所以釋放時，要對每個單元里的指針指向的內存予以釋放。釋放內存代碼如下：

for(i=0;i??????delete[] array[i];
delete[] array;

?

?

malloc函數(shù)
原型：extern void *malloc(unsigned int num_bytes);

用法：#include

功能：分配長度為num_bytes字節(jié)的內存塊

說明：如果分配成功則返回指向被分配內存的指針，否則返回空指針NULL。
當內存不再使用時，應使用free()函數(shù)將內存塊釋放。

舉例：
// malloc.c

#include

clrscr(); // clear screen
p=(char *)malloc(100);
if(p)
printf("Memory Allocated at: %x",p);
else
printf("Not Enough Memory!n");
free(p);

getchar();
return 0;
}

函數(shù)聲明(函數(shù)原型)：
void *malloc(int size);
說明：malloc 向系統(tǒng)申請分配指定size個字節(jié)的內存空間。返回類型是 void* 類型。void* 表示未確定類型的指針。C,C++規(guī)定，void* 類型可以強制轉換為任何其它類型的指針。
從函數(shù)聲明上可以看出。malloc 和 new 至少有兩個不同: new 返回指定類型的指針，并且可以自動計算所需要大小。比如：
int *p;
p = new int; //返回類型為int* 類型(整數(shù)型指針)，分配大小為 sizeof(int);
或：
int* parr;
parr = new int [100]; //返回類型為 int* 類型(整數(shù)型指針)，分配大小為 sizeof(int) * 100;
而 malloc 則必須由我們計算要字節(jié)數(shù)，并且在返回后強行轉換為實際類型的指針。
int* p;
p = (int *) malloc (sizeof(int));
第一、malloc 函數(shù)返回的是 void * 類型，如果你寫成：p = malloc (sizeof(int)); 則程序無法通過編譯，報錯：“不能將 void* 賦值給 int * 類型變量”。所以必須通過 (int *) 來將強制轉換。
第二、函數(shù)的實參為 sizeof(int) ，用于指明一個整型數(shù)據(jù)需要的大小。如果你寫成：
int* p = (int *) malloc (1);
代碼也能通過編譯，但事實上只分配了1個字節(jié)大小的內存空間，當你往里頭存入一個整數(shù)，就會有3個字節(jié)無家可歸，而直接“住進鄰居家”！造成的結果是后面 的內存中原有數(shù)據(jù)內容全部被清空。
malloc 也可以達到 new [] 的效果，申請出一段連續(xù)的內存，方法無非是指定你所需要內存大小。
比如想分配100個int類型的空間：
int* p = (int *) malloc ( sizeof(int) * 100 ); //分配可以放得下100個整數(shù)的內存空間。
另外有一點不能直接看出的區(qū)別是，malloc 只管分配內存，并不能對所得的內存進行初始化，所以得到的一片新內存中，其值將是隨機的。
除了分配及最后釋放的方法不一樣以外，通過malloc或new得到指針，在其它操作上保持一致。

對其做一個特例補充
char *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Got a null pointer");
else
puts("Got a valid pointer");
此時得到的是Got a valid pointer。把0賦給maclloc能得到一個合法的指針。

struct hostent *hp;

//注意是sizeof( sturct hostent )而不是sizeof( sturct hostent* )
//其中N代表你需要的sturct hostent類型數(shù)據(jù)的數(shù)量
hp = ( struct hostent* ) malloc ( N * sizeof( sturct hostent ) );

if ( !hp )??????//建議要加上這個內存分配成功與否的檢測
{
// 添加內存分配失敗時的處理方法
}

new delete, free malloc

首先應該知道m(xù)alloc 和free是匹配的；new和delete是匹配的，他們不可以混淆。???

malloc和new都申請空間，但是new是強類型的分配，會調用對象的構造函數(shù)初始化對象，而malloc僅分配內存空間但是不初始化。

new???自適應類型，malloc需要強制轉換new按類型進行分配，malloc需要指定內存大小對于對象來說free的確釋放了對象的內存，但是不調用對象的 析構函數(shù)。delete不僅釋放對象的內存，并且調用對象的析構函數(shù)所以在對象中用free刪除new創(chuàng)建的對象，內存就有可能泄露在delete內部仍 調用了free .

補充一點：new和malloc雖然都是申請內存，但申請的位置不同，new的內存從free store分配，而malloc的內存從heap分配（詳情請看ISO14882的內存管理部分），free store和heap很相似，都是動態(tài)內存，但是位置不同，這就是為什么new出來的內存不能通過free來釋放的原因。不過微軟編譯器并沒有很好的執(zhí)行 標準，很有可能把free store和heap混淆了，因此，free有時也可以。

再補充一點：delete時候不需要檢查NULL

delete???NULL;??????是沒有任何問題的，所以?????

if(p)?????

{?????????????????

delete???p;?????????????????

p???=???NULL;?????

}?????

還不如?????

delete???p;?????

p???=???NULL;

而free(NULL)那就麻煩大了。

1.malloc與free是C++/C語言的標準庫函數(shù)，new/delete是C++的 運算符。它們都可用于申請動態(tài)內存和釋放內存。
2.對于非內部數(shù)據(jù)類型的對象而言，光用maloc/free無 法滿足動態(tài)對象的要求。對象在創(chuàng)建的同時要自動執(zhí)行構造函數(shù)，對象在消亡之前要自動執(zhí)行析構函數(shù)。由于malloc/free是 庫函數(shù)而不是運算符，不在編譯器控制權限之內，不能夠把執(zhí)行構造函數(shù)和析構函數(shù)的任務強加于malloc/free。
3.C++語 言需要一個能完成動態(tài)內存分配和初始化工作的運算符new，以及一個能完成清理與釋放內存工作的運算符delete。 注意new/delete不是庫函數(shù)。
我們先看一看malloc/free和new/delete如 何實現(xiàn)對象的動態(tài)內存管理，見示例7-8。
class?Obj
{
public?:

Obj(void){ cout?<<?“Initialization”?<<?endl; }
~Obj(void){ cout?<<?“Destroy”?<<?endl; }
void????Initialize(void){ cout?<<?“Initialization”?<<?endl; }
void????Destroy(void){ cout?<<?“Destroy”?<<?endl; }
};
void?UseMallocFree(void)
{???Obj??*a?=?(obj?*)malloc(sizeof(obj));???//?申請動態(tài)內存
????a->Initialize();????????????????????????//?初始化
//...?a->Destroy();???//?清除工作
????free(a);????????//?釋放內存
}
void?UseNewDelete(void)
{
Obj??*a?=?new?Obj;??//?申請動態(tài)內存并且初始化
?????//...delete a;???????????//?清除并且釋放內存
}
示例7-8?用malloc/free和new/delete如 何實現(xiàn)對象的動態(tài)內存管理
類Obj的函數(shù)Initialize模 擬了構造函數(shù)的功能，函數(shù)Destroy模擬了析構函數(shù)的功能。函數(shù)UseMallocFree中， 由于malloc/free不能執(zhí)行構造函數(shù)與析構函數(shù)，必須調用成員函數(shù)Initialize和Destroy來 完成初始化與清除工作。函數(shù)UseNewDelete則簡單得多。

所以我們不要企 圖用malloc/free來完成動態(tài)對象的內存管理，應該用new/delete。由于內部數(shù)據(jù) 類型的“對象”沒有構造與析構的過程，對它們而言malloc/free和new/delete是 等價的。
4.既然new/delete的功能完全覆蓋了malloc/free， 為什么C++不把malloc/free淘汰出局呢？這是因為C++程 序經常要調用C函數(shù)，而C程序只能用malloc/free管理動態(tài)內 存。

如果用free釋放“new創(chuàng)建的動態(tài)對象”，那 么該對象因無法執(zhí)行析構函數(shù)而可能導致程序出錯。如果用delete釋放“malloc申請的動態(tài) 內存”，理論上講程序不會出錯，但是該程序的可讀性很差。所以new/delete必須配對使用，malloc/free也 一樣。

5.new的幾種用法：

int?*p=new?int;?//在自由存儲區(qū)開辟一個int變量?
int?*p=new?int[10];//在自由存儲區(qū)開辟一個 int數(shù)組，有10個元素
int?*p=new?int(10);//在自由存儲區(qū)開辟一個int變量,并初始化為10