C/C++中的malloc、calloc与new的区别

本文主要是介绍C/C++中的malloc、calloc与new的区别，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

函数malloc()和calloc()都可以用来动态分配内存空间,但两者稍有区别。

malloc()函数有一个参数,即要分配的内存空间的大小：

void *malloc(size_t size);

calloc()函数有两个参数,分别为元素的数目和，每个元素的大小,这两个参数的乘积就是要分配的内存空间的大小：

void *calloc(size_tnumElements,size_tsizeOfElement);

如果调用成功,函数malloc()和函数calloc()都将返回所分配的内存空间的首地址。

函数malloc()和函数calloc()的主要区别是前者不能初始化所分配的内存空间,而后者能。如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之,如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据。也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题。函数calloc()会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那麽这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那麽这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零。需要包含头文件：

#include或#include函数声明(函数原型)：

void *malloc(int size);

说明：malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void*表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。从函数声明上可以看出。malloc 和 new 至少有两个不同: new 返回指定类型的指针，并且可以自动计算所需要大小。比如：

int *p;

p = new int; //返回类型为int* 类型(整数型指针)，分配大小为 sizeof(int);或：

int* parr;

parr = new int [100]; //返回类型为 int*类型(整数型指针)，分配大小为 sizeof(int)* 100;而 malloc 则必须由我们计算要字节数，并且在返回后强行转换为实际类型的指针。

int* p;

p = (int *) malloc (sizeof(int));

第一、malloc 函数返回的是 void * 类型，如果你写成：p = malloc (sizeof(int)); 则程序无法通过编译，报错：“不能将 void* 赋值给 int * 类型变量”。所以必须通过 (int *)来将强制转换。

第二、函数的实参为 sizeof(int) ，用于指明一个整型数据需要的大小。如果你写成：int* p = (int *) malloc(1);代码也能通过编译，但事实上只分配了1个字节大小的内存空间，当你往里头存入一个整数，就会有3个字节无家可归，而直接“住进邻居家”！造成的结果是后面的内存中原有数据内容全部被清空。malloc 也可以达到 new [] 的效果，申请出一段连续的内存，方法无非是指定你所需要内存大小。比如想分配100个int类型的空间：

int* p = (int *) malloc ( sizeof(int) *100 ); //分配可以放得下100个整数的内存空间。

另外有一点不能直接看出的区别是，malloc 只管分配内存，并不能对所得的内存进行初始化，所以得到的一片新内存中，其值将是随机的除了分配及最后释放的方法不一样以外，通过malloc或new得到指针，在其它操作上保持一致。

new运算符用作从自由存储为 type-name 的对象或对象数组分配内存，并将已适当分类的非零指针返回到对象。

 ? 
 [::] new [placement] new -type-name [ new -initializer] 
 [::] new [placement] ( type-name ) [ new -initializer] 

备注
如果不成功，则 new 将返回零或引发异常；有关详细信息，请参阅 new 和 delete 运算符。通过编写自定义异常处理例程并调用 _set_new_handler 运行库函数（以您的函数名称作为其参数），可以更改此默认行为。
有关如何在托管堆上创建对象的信息，请参阅 gcnew。
使用 new 为 C++ 类对象分配内存时，将在分配内存后调用对象的构造函数。
使用 delete 运算符可解除分配使用 new 运算符分配的内存。
以下示例先分配然后释放一个二维字符数组，数组的大小为 dim x 10。在分配多维数组时，除第一个维度之外的所有维度必须是计算结果为正值的常量表达式；最左侧的数组维度可以是计算结果为正值的任何表达式。在使用 new 运算符分配数组时，第一个维度可为零 - new 运算符将返回一个唯一指针。

 ? 
 char (*pchar)[10] =  new char [dim][10]; 
 delete [] pchar; 

type-name 不能包含 const、volatile、类声明或枚举声明。因此，以下表达式是非法的：

 ? 
 volatile char *vch =  new volatile char [20]; 

new 运算符不会分配引用类型，因为这些类型不是对象。
new 运算符无法用于分配函数，但可用于分配指向函数的指针。下面的示例为返回整数的函数分配然后释放一个包含 7 个指针的数组。

 ? 
 int (**p) () =  new ( int (*[7]) ()); 
 delete *p; 

如果使用不带任何额外参数的 new 运算符，并用 /GX、/EHa 或 /EHs 选项进行编译，则编译器将在构造函数引发异常时生成代码来调用运算符 delete。
以下列表描述了 new 的语法元素：
placement
如果重载 new，则提供了一种传递附加参数的方式。
type-name
指定要分配的类型；它可以是内置类型，也可以是用户定义的类型。如果类型规范非常复杂，则可用括号将其括起来以强制实施绑定顺序。
initializer
为初始化对象提供值。不能为数组指定初始值设定项。仅当类具有默认构造函数时，new 运算符才会创建对象的数组。
示例
下面的代码示例分配类 CName 的一个字符数组和一个对象，然后释放它们。

 ? 
 // expre_new_Operator.cpp 
 // compile with: /EHsc 
 #include <string.h> 
 class CName { 
 public : 
    enum { 
     sizeOfBuffer = 256 
    }; 
    char m_szFirst[sizeOfBuffer]; 
    char m_szLast[sizeOfBuffer]; 
 public : 
    void SetName( char * pszFirst,  char * pszLast) { 
     strcpy_s(m_szFirst, sizeOfBuffer, pszFirst); 
     strcpy_s(m_szLast, sizeOfBuffer, pszLast); 
    } 
 }; 
 int main() { 
    // Allocate memory for the array 
    char * pCharArray =  new char [CName::sizeOfBuffer]; 
    strcpy_s(pCharArray, CName::sizeOfBuffer,  "Array of characters" ); 
    // Deallocate memory for the array 
    delete [] pCharArray;       
    pCharArray = NULL; 
    // Allocate memory for the object 
    CName* pName =  new CName; 
    pName->SetName( "Firstname" , "Lastname" ); 
    // Deallocate memory for the object 
    delete pName; 
    pName = NULL; 
 } 

如果使用 new 运算符的放置新形式（带有参数和分配大小的形式），如果构造函数引发异常，则编译器不支持 delete 运算符的放置形式。例如:

 ? 
 // expre_new_Operator2.cpp 
 // C2660 expected 
 class A { 
 public : 
    A( int ) {  throw "Fail!" ; } 
 }; 
 void F( void ) { 
    try { 
     // heap memory pointed to by pa1 will be deallocated 
     // by calling ::operator delete(void*). 
     A* pa1 =  new A(10); 
    } catch (...) { 
    } 
    try { 
     // This will call ::operator new(size_t, char*, int). 
     // When A::A(int) does a throw, we should call 
     // ::operator delete(void*, char*, int) to deallocate 
     // the memory pointed to by pa2. Since 
     // ::operator delete(void*, char*, int) has not been implemented, 
     // memory will be leaked when the deallocation cannot occur. 
     A* pa2 =  new (__FILE__, __LINE__) A(20); 
    } catch (...) { 
    } 
 } 
 int main() { 
    A a; 
 } 

初始化使用 new 运算符分配的对象
可选的 initializer 字段包含在 new 运算符的语法中。这样就可以使用用户定义的构造函数来初始化新对象。有关如何执行初始化的详细信息，请参阅初始值设定项。以下示例演示如何将初始化表达式与 new 运算符一起使用：

 ? 
 // expre_Initializing_Objects_Allocated_with_new.cpp 
 class Acct 
 { 
 public : 
    // Define default constructor and a constructor that accepts 
    // an initial balance. 
    Acct() { balance = 0.0; } 
    Acct( double init_balance ) { balance = init_balance; } 
 private : 
    double balance; 
 }; 
 int main() 
 { 
    Acct *CheckingAcct =  new Acct; 
    Acct *SavingsAcct =  new Acct ( 34.98 ); 
    double *HowMuch =  new double ( 43.0 ); 
    // ... 
 } 

在此示例中，使用 CheckingAcctnew 运算符分配了对象，但未指定默认初始化。因此，调用了类的默认构造函数 Acct()。然后，以相同的方式分配了对象 SavingsAcct，只不过将它显式初始化为 34.98。由于 34.98 是类型 double，因此调用了采用该类型的参数的构造函数来处理初始化。最后，将非类类型 HowMuch 初始化为 43.0。
如果对象是类类型，并且该类具有构造函数（如前面的示例所示），则仅当满足以下条件之一时，new 运算符才能初始化该对象：
初始值设定项中提供的参数与构造函数的参数一致。
该类有一个默认构造函数（可在没有参数的情况下调用的构造函数）。
访问控制和二义性控制根据operator new多义性和使用特殊成员函数的初始化中所述的规则对和构造函数执行。
在使用 new 运算符分配数组时，无法对每个元素执行显式初始化；只调用了默认构造函数（如果有）。有关详细信息，请参阅默认参数。
如果内存分配失败（operator new 的返回值为 0），则不执行初始化。这可防止尝试初始化不存在的数据。
与函数调用一样，未定义初始化表达式的计算顺序。此外，您不应指望这些表达式能在执行内存分配前完全计算。如果内存分配失败，并且 new 运算符返回零，则可能不会完全计算初始值设定项中的某些表达式。
使用 new 运算符分配的对象的生存期
在退出分配有 new 运算符的对象的定义范围时，将不会销毁这些对象。由于 new 运算符将返回指向其所分配的对象的指针，因此程序必须使用合适的范围定义指针才能访问这些对象。例如:

 ? 
 // expre_Lifetime_of_Objects_Allocated_with_new.cpp 
 // C2541 expected 
 int main() 
 { 
    // Use new operator to allocate an array of 20 characters. 
    char *AnArray =  new char [20]; 
    for ( int i = 0; i < 20; ++i ) 
    { 
      // On the first iteration of the loop, allocate 
      // another array of 20 characters. 
      if ( i == 0 ) 
      { 
        char *AnotherArray =  new char [20]; 
      } 
    } 
    delete [] AnotherArray； // Error: pointer out of scope. 
    delete [] AnArray;    // OK: pointer still in scope. 
 } 

在上面的示例中，指针 AnotherArray 一旦超出范围，将无法再删除对象。

new 的工作方式
allocation-expression（包含 new 运算符的表达式）执行三类操作：
定位并保留要分配的对象的存储。此阶段完成后，将分配正确的存储量，但它还不是对象。
初始化对象。初始化完成后，将为成为对象的已分配存储显示足够的信息。
返回指向派生自 new-type-name 或 type-name 的指针类型的对象的指针。程序使用此指针来访问最近分配的对象。
new 运算符调用函数 operator new。对于任何类型的数组以及不属于 class、struct 或 union 类型的对象，调用全局函数 ::operator new 来分配存储。类类型对象可基于每个类定义其自己的 operator new 静态成员函数。
当编译器遇到用于分配 type 类型的对象的 new 运算符时，它将发出对 type::operator new( sizeof( type ) ) 的调用；或者，如果不存在用户定义的 operator new，则调用 ::operator new( sizeof( type ) )。因此，new 运算符可以为对象分配正确的内存量。

关于“C语言中的malloc和C++中new的区别”可以参考：C语言中的malloc和C++中new的区别_百度文库 http://wenku.baidu.com/view/fe609a4231126edb6f1a10dc.html

这篇关于C/C++中的malloc、calloc与new的区别的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！