[转载]C++指针new和malloc区别

学海无涯GL 2013-09-23

展开全文

一.new 的几种基本用法

1.创建一个动态变量

int *p;
p=new int; //new int 操作时的在堆区产生一个int型的动态变量，结果为该动态变量的地址（或指针）。
*p=1;

2.创建一个一维n位动态数组

    int *p;
   int n;
   p=new int[n]; // 操作在程序的堆区中产生一个动态的一维数组，数组元素的类型是int，返回值为数组的首地址。

3.创建一个n*20的动态数组

int (*q)[20]; //定义q为一个指向20个int型元素所构成的一维数组的指针。等价于 typedef int A[20]; A* q;
q=new int[n][20]; //上面这一段会产生error，因为无法从int (*)[20]转化为 int *;

4.创建一个m*n的动态数组

    int m,n;
    cin>>m>>n;
    int **p = new int*[n];
    for (int i=0; i<n; ++i)
    p[i] = new int[m]; //定义一个n*m的二维动态数组

二.malloc的用法

1.malloc在 cstdlib中声明，在程序的堆区中分配一块大小为size的内存空间，并返回该内存空间的的首地址。

2.malloc 函数原型：

void *malloc(unsigned int size);

3.具体使用

int *p;

p=(int *)malloc(sizeof(int)); //创建一个int型的动态变量

double *q;

int n;

q=(double *)malloc(sizeof(double)*n); //创建一个由n个double型元素组成的一位动态数组

typedef int A[20];

int *q=(int *)malloc(sizeof(int)*20); //创建一个n行，20列的动态二维数组变量

三.new与delete的区别

1.new自动计算所需分配空间的大小，delete需要显式的指出。

2.new自动返回相应类型的指针，delete需要做强制类型的转化。

3.如果创建的是动态对象，new会去调用相应对象类的构造函数，而malloc不会。

四.动态数组的撤销

1.new创建的delete使之消亡，malloc创建的free使之消亡。

2.delete格式如下：

int *p=new int;

delete p;

int *p=new int[20];

delete[]p;

3.free的格式如下：

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

int *q=(int *)malloc(sizeof(int)*20);

free(p);

free(q);

4.delete与free的区别

如果p指向的是对象（或对象数组），则delete p（或delete []p）回去调用对象类的析构函数，而free不会。

5.悬浮指针（dangling pointer）

撤销后，c++编译程序一般不会把指向它的指针变量的值赋为NULL，这样就产生了一个悬浮指针，它指向一个无效的空间。在通过这个悬浮指针来使用相应的动态变量就会产生语义错误。

6.内存泄漏（memory leak）

如果不去撤销它，而指向了别的地方，那个空间就会浪费掉。

原文地址：C++ 指针 new和malloc 区别作者：潇湘浪子

1、

delete一个指针，是指删除掉指针指到的东西，比如你上面删除的是10，同时会更改内存结构链表，同时告诉操作系统这块内存free了，可以继续使用了。所以一般的书上都建议delete一个指针后把这个指针置为NULL，以避免一些错误的发生，因为delete一个NULL指针，在一些编译器编译的程序中是什么都不做的，比如BCB。
所以应该是：

delete a;

a = NULL;

2、

为了避免释放已经释放了内存的指针内存，或没有释放内存，在c语言中最好是在定义指针时赋初值NULL，释放后立即赋NULL,释放时检查指针值再决定释放就避免释放错误了，如：

int *a = NULL
int *b = (int*) malloc(sizeof(int) * 10);
int *c = NULL, *d = NULL;
c = b;
d = a;

if(a != NULL) free(a);
if(b != NULL) free(b);
if(c != NULL) free(c);
if(d != NULL) free(d);

new和malloc操作符的区别

1、new 是c++中的操作符，malloc是c 中的一个函数

2、new 不止是分配内存，而且会调用类的构造函数，同理delete会调用类的析构函数，而malloc则只分配内存，不会进行初始化类成员的工作，同样free也不会调用析构函数

3、内存泄漏对于malloc或者new都可以检查出来的，区别在于new可以指明是那个文件的那一行，而malloc没有这些信息。

4、new 和 malloc效率比较

new可以认为是malloc加构造函数的执行。

new出来的指针是直接带类型信息的。

而malloc返回的都是void指针。

一：new delete 是运算符，malloc,free是函数

malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。注意new/delete不是库函数。

我们先看一看malloc/free和new/delete如何实现对象的动态内存管理，见示例。

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)); // 申请动态内存

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

//…

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

free(a); // 释放内存

}

void UseNewDelete(void)

{

Obj *a = new Obj; // 申请动态内存并且初始化

//…

delete a; // 清除并且释放内存

}

示例用malloc/free和new/delete如何实现对象的动态内存管理

类Obj的函数Initialize模拟了构造函数的功能，函数Destroy模拟了析构函数的功能。函数UseMallocFree中，由于malloc/free不能执行构造函数与析构函数，必须调用成员函数Initialize和Destroy来完成初始化与清除工作。函数UseNewDelete则简单得多。

所以我们不要企图用malloc/free来完成动态对象的内存管理，应该用new/delete。由于内部数据类型的“对象”没有构造与析构的过程，对它们而言malloc/free和new/delete是等价的。

既然new/delete的功能完全覆盖了malloc/free，为什么C++不把malloc/free淘汰出局呢？这是因为C++程序经常要调用C函数，而C程序只能用malloc/free管理动态内存。

如果用free释放“new创建的动态对象”，那么该对象因无法执行析构函数而可能导致程序出错。如果用delete释放“malloc申请的动态内存”，理论上讲程序不会出错，但是该程序的可读性很差。所以new/delete必须配对使用，malloc/free也一样。

二：new delete在实现上其实调用了malloc,free函数。

三：new operator除了分配内存，还要调用构造函数。

malloc函数只是负责分配内存。

1． malloc是库函数，在C++程序中，要用到malloc函数，必须包含malloc.h。malloc函数的原型是：void *malloc( size_t size ),其中，size是分配的空间大小。该函数返回一个void类型的指针，因此，在用malloc函数时，往往需要进行数据类型的强制转换：
              int *pm = (int*)malloc(2);
             myclass *pO1 = (myclass *)malloc(2); //myclass是一个自定义的类
       new是C++的一个运算符，一般用法如下：
int *p = new int[10];
              myclass *pO = new myclass;
2．在分配空间时，malloc只是分配了指定大小的空间，并没有初始化，没有调用类的构造函数。而new不仅分配了空间，同时进行了初始化工作，调用了该对象的构造函数。
如下面的一个例程所示：

#include <iostream.h> #include <malloc.h> class myclass ...{ public: myclass(); void myfoo(); private: int m_nindex; }; myclass::myclass() ...{ m_nindex = 1; } void myclass::myfoo() ...{ cout << " myfoo : m_nindex = " << m_nindex << endl; } int main() ...{ int *p = new int[10]; myclass *pO = new myclass; myclass *pO1 = (myclass *)malloc(2); for(int i =0; i<10; i++) ...{ p[i] = i; cout << p[i] << " "; } cout << endl; pO->myfoo(); pO1[0].myfoo(); pO1[1].myfoo(); delete[] p; delete pO; free(pO1); return 0; }