总结并剖析malloc/free和new/delete之间关系和差异

总结并剖析malloc/free和new/delete之间关系和差异

两者相同点

1.都可以申请动态堆内存。

两者不同点

1.new/delete是C++的操作符，malloc/free是C/C++的标准库函数。
2.new申请的可以理解为对象，new时会调用构造函数，返回指向该对象的指针，delete时调用析构函数；malloc申请的只是内存，不是对象。

3.new/delete是保留字，不需要头文件支持；malloc/free需要头文件库函数支持。

注意事项

1.用new申请的内存，必须用delete释放。
2.用new[]申请的内存，必须用delete[]释放。
3.delete释放内存后，指针值不变，良好的风格是释放后指针置为NULL，如,delete p； p = NULL。
4.用malloc申请的内存，必须用free释放。

使用

#include "stdafx.h"  
#include <stdio.h>  
#include "stdlib.h"  
#include <string.h>  
  
struct Stu  
{  
    char    name[32];  
    int     age;  
};  
  
int main()  
{  
/**************************** 基本用法 **********************************/  
  
    //申请一个int类型  
    int *p1 = new int;      //直接申请赋值  int* p1 = new int(3);  
    int *p2 = (int*)malloc(sizeof(int));  
  
    //申请一个char类型  
    char *p3 = new char;    //直接申请赋值    char *p3 = new char('c');  
    char *p4 = (char*)malloc(sizeof(char));  
  
    //申请一个int型一维数组  
    int *p5 = new int[5];   //直接申请赋值    int *p5 = new int[5]{1,2,3,4,5};  
    int *p6 = (int*)malloc(sizeof(int)*5);  
      
    //申请一个char型一维数组  
    char* p7 = new char[6]; //直接申请赋值  char* p7 = new char[3]{'a', 'v', 'c'};  
    char* p8 = (char*)malloc(sizeof(char)*6);  
      
    //申请一个int型二维数组  
    int(*p9)[2] = new int[2][2]; //直接申请赋值   int(*p9)[2] = new int[2][2]{ 1,2,3,4 };  
    int(*p10)[2] = (int(*)[2])malloc(sizeof(int)*2*2);  
      
    //申请一个char型二维数组  
    char(*p11)[2] = new char[2][2];  
    char(*p12)[2] = (char(*)[2])malloc(sizeof(char)*2*2);  
  
/***************************** 申请二级指针内存 **********************************/  
      
    //申请二级指针(new,delete)  
    char** p13 = new char*[2];  
    p13[0] = "aaaaaaaaaa";  
    p13[1] = "vvvvvvvvvv";  
    delete p13;  
  
    //申请二级指针(malloc, free)  
    char** p14 = (char**)malloc(sizeof(char*)*2);  
    p14[0] = "cccccccc";  
    p14[1] = "dddddddd";  
    delete p14;  
  
/****************************** 申请结构体内存 *********************************/  
  
    //new delete  
    Stu* pStu1 = new Stu;  
    Stu* pStu2 = new Stu{"wpf", 10};  
    Stu* pStu3 = new Stu[1024];  
    delete pStu1;  
    delete pStu2;  
    delete[] pStu3;  
  
    //malloc free  
    Stu* pStu4 = (Stu*)malloc(sizeof(Stu));  
    memset(pStu4, 0, sizeof(Stu));  
    free(pStu4);  
  
    getchar();  
}  

剖析new/delete、new[]/delete[]到底做了些什么事情

一.基本使用

当我们想要对一段未命名内存分配内容的时候，只能通过指针来访问该内存，我们可以用指针配合new运算符来开辟内存(malloc也可以实现)。我们需要告诉new我们要在内存里存储什么样的数据类型，使用模式如下：

typeName * Pointer_name = new typeName;

在使用new开启了内存空间存储了数据以后，我们在使用完毕后需要使用delete释放掉开辟的内存，方法很简单：

delete Pointer_name;

注意两点：

1.delete只能释放new开启的内存，不要用delete释放声明变量所开辟的内存。

2.delete用来作用于new开辟的地址而不是new对应的指针，例如：

int * Pt = new int;

int * Pg = Pt;

delete Pg;

此处，指针Pg指向new开辟的内存，所以释放掉Pg即可，不需要释放掉new对应的指针Pt。

二.动态数组

如果通过声明来定义数组，程序会在编译时对它分配内存，因此必须明确数组的大小。而如果我们通过使用new来创建动态数组，则是在程序运行的时候才对它分配内存，且可以在程序运行时选择数组的长度。格式如下：

typeName * Pointer_name = new typeName [num_element];

new运算符返回数组的第一个地址，被分配给指针。

释放动态数组内存的方法也很简单：

delete [] Pointer_name;

这个方括号告诉程序，应该释放整个数组的内存，而不是指针指向元素的内存。

使用new遵循原则：

  a.用new申请的内存，必须用delete释放。

  b.用new[]申请的内存，必须用delete[]释放。

  c.delete释放内存后，指针值不变，良好的风格是释放后指针置为NULL，如,delete p； p = NULL。

使用

1.申请一个对象

int* p1 = new int;  
delete p1;  
p1 = NULL;

2.申请多个对象

int* p1 = new int[12];  
delete[] p1;  
p1 = NULL;  

3.申请一个长度为1024的char数组

char* pArray = new char[1024];  
for (int i=0; i < 1024; i++)  
{  
    pArray[i] = i;  
}  
delete[] pArray;  
pArray = NULL;

4.申请一个类对象

#include <stdio.h>  
  
class Student  
{  
public:  
    char name[32];  
    int  age;  
};  
int main()  
{  
    Student* pStu = new Student();  
    delete pStu;  
    pStu = NULL;  
    return 1;  
}  

5.申请1024个类对象

#include <stdio.h>  
  
class Student  
{  
public:  
    int age;  
    Student()  
    {  
        ...  
    }  
    ~Student()  
    {  
        ...  
    }  
};  
  
int main()  
{  
    Student* pStu = new Student[1024];  
    for (int i=0; i<1024; i++)  
    {  
        pStu[i].age = i+1;  
    }  
    delete[] pStu;  
    pStu = NULL;  
    return 1;  
}  

new多个对象不能传参数，要求该类必须有默认构造函数。