码迷,mamicode.com
首页 > 编程语言 > 详细

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

时间:2016-05-12 15:21:37      阅读:303      评论:0      收藏:0      [点我收藏+]

标签:

函数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 的对象或对象数组分配内存,并将已适当分类的非零指针返回到对象。

?
1
2
[::]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 运算符将返回一个唯一指针。

?
1
2
char(*pchar)[10] = newchar[dim][10];
delete[] pchar;

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

?
1
volatilechar*vch = newvolatilechar[20];

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

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

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// expre_new_Operator.cpp
// compile with: /EHsc
#include <string.h>
 
classCName {
public:
  enum{
   sizeOfBuffer = 256
  };
 
  charm_szFirst[sizeOfBuffer];
  charm_szLast[sizeOfBuffer];
 
public:
  voidSetName(char* pszFirst, char* pszLast) {
   strcpy_s(m_szFirst, sizeOfBuffer, pszFirst);
   strcpy_s(m_szLast, sizeOfBuffer, pszLast);
  }
 
};
 
intmain() {
  // Allocate memory for the array
  char* pCharArray = newchar[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 = newCName;
  pName->SetName("Firstname","Lastname");
 
  // Deallocate memory for the object
  deletepName;
  pName = NULL;
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// expre_new_Operator2.cpp
// C2660 expected
classA {
public:
  A(int) { throw"Fail!"; }
};
voidF(void) {
  try{
   // heap memory pointed to by pa1 will be deallocated
   // by calling ::operator delete(void*).
   A* pa1 = newA(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(...) {
  }
}
 
intmain() {
  A a;
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// expre_Initializing_Objects_Allocated_with_new.cpp
classAcct
{
public:
  // Define default constructor and a constructor that accepts
  // an initial balance.
  Acct() { balance = 0.0; }
  Acct(doubleinit_balance ) { balance = init_balance; }
private:
  doublebalance;
};
 
intmain()
{
  Acct *CheckingAcct = newAcct;
  Acct *SavingsAcct = newAcct ( 34.98 );
  double*HowMuch = newdouble( 43.0 );
  // ...
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// expre_Lifetime_of_Objects_Allocated_with_new.cpp
// C2541 expected
intmain()
{
  // Use new operator to allocate an array of 20 characters.
  char*AnArray = newchar[20];
 
  for(inti = 0; i < 20; ++i )
  {
    // On the first iteration of the loop, allocate
    // another array of 20 characters.
    if( i == 0 )
    {
      char*AnotherArray = newchar[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的区别

标签:

原文地址:http://blog.csdn.net/smf0504/article/details/51361116

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!