new 和 malloc 区别

参考博客：
https://blog.csdn.net/xiaorenwuzyh/article/details/44514815
https://blog.csdn.net/xw13106209/article/details/4962479
https://www.cnblogs.com/maluning/p/7944231.html

每个程序在执行时都会占用一块可用的内存空间，用于存放动态分配的对象，此内存空间称为自由存储区或堆。

1. new的用法

1.1 new的基本用法：

int *pi = new int;//在自由存储区中分配创建了一个整形对象，并返回一个指向该对象的地址来初始化指针pi
int *pi = new int();//只是对指针pi指向的地址的值进行了初始化为0
int *pi = new int(1024);//第三行初始化为1024。

//当创建一个动态数组对象和进行内存释放时，执行以下语句：
int *pi = new int[];//指针pi所指向的数组未初始化
int *pi = new int[n];//指针pi指向长度为n的数组，未初始化
int *pi = new int[]();//指针pi所指向的地址初始化为0
delete [] pi;//回收pi所指向的数组

int *a = new int[5];
class A{...}  //声明一个类
A *obj = new A();  //使用new创建对象
delete []a;
delete obj;

这里我们注意，new int[5] 仅仅分配了空间， 但是 new A()，不仅仅为对象obj在队上分配了空间， 而且还调用了 A的构造函数，生成了这个对象。
​所以 new A() 这样方式的功能如下:

• 在堆上分配内存；
• 在分配的空间上调用对象的构造函数。
  这也是new 和 malloc的主要区别，是否调用构造函数
  同理: 在调用 delete obj的时候：
• 首先调用 这个对象 的析构函数 ；
• 然后释放这个对象的空间。

1.2 new的升级版本

从上面可以看到：new 的功能是 1. 分配空间， 2 调用构造函数。 那么到底是如何实现的呢？
其实 C++ 规定 new 的 这 两个功能分开实现：

1. 分配空间： 调用函数 operator new 来实现。
2. 调用构造函数： 调用 placement new 来实现。

现在有三个 new 了，第一个new就是我们常说的new， 这个new 调用 接下来的两个new 来实现它的功能。 （我们称这个 new 为， new operator，叫做“new 表达式”，因为operator 在 new 后面，所以 叫做 “new 表达式”，也就是关键字）
​ new关键字 会调用 operator new 分配空间： 这里 operator new 是一个全局的函数，写在一个文件中。当使用 new 关键字 的时候，编译器会自动找到这个函数，并且调用这个函数：这个函数的声明如下:

// 全局 operator new
void * operator new(std::size_t size) throw(std::bad_alloc) {
    if (size == 0)
        size = 1;
    void* p;
    while ((p = ::malloc(size)) == 0) { //采用 malloc 分配空间
        std::new_handler nh = std::get_new_handler();
        if (nh)
            nh();
        else
            throw std::bad_alloc();
    }
    return p;
}
// 对应的全局 operator delete 采用 free 释放空间
void operator delete(void* ptr) {
    if (ptr)
        ::free(ptr); //采用 free 释放空间。
}

全局operator new 分配内存

从上个例子中可以看到， 全局 operator new 分配空间，简单的调用了 malloc() 函数来分配空间。 并没有做任何初始化工作。
现在问题来了： 已经有了一段分配好的空间 ，如何在这个空间上 调动这个类的构造函数，从而真正的创建一个对象呢？ （你需要对 对象的 内存模型 有一定的了解）。 解决方案是： placement new

placement new 调用构造函数

placement new 的功能就是 在一个已经分配好的空间上，调用构造函数，创建一个类。
​ placement new 就这一个用法，知道如何用就可以了，它不是一个（写在文件中）函数，是编译器编译时候做的事情。
用法如下：

void *buf = //在这里为buf分配内存
class *pc = new (buf) class();

举例：

class A{...};
viod *buf = malloc(sizeof(A));// 简单的分配空间
A *obj = new (buf)A();//在分配的空间上调用构造函数

2. malloc的用法

malloc和free两个函数的原型如下，他们都在头文件stdlib.h中声明。

void *malloc(size_t size);
void free(void *pointer);

int *p = (*int)malloc(100);//指向整型的指针p指向一个大小为100字节的内存的地址
int *p = (*int)malloc(25*sizeof(int));//指向整型的指针p指向一个25个int整型空间的地址

//验证内存是否分配成功，完成后用free()释放内存
int *p=(int *)malloc(int);
if(p==NULL)
    printf("Out of memory!\n");
free (p);

malloc 向系统申请分配指定size个字节的内存空间。返回类型是 void* 类型。void* 表示未确定类型的指针。C,C++规定，void* 类型可以强制转换为任何其它类型的指针。

3. new和malloc的区别

3.1 new返回指定类型的指针，并且可以自动计算所需要的内存的大小；而malloc必须要自己计算所需要的字节数，并且返回的是void*类型，需要强行转换为实际类型的指针。

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得到指针，在其它操作上保持一致。

3.2 总结：

malloc函数其实就是在内存中找到一片指定大小的空间，然后将这个空间的首地址返回给一个指针变量，这里的指针变量可以使一个单独的指针，也可以是一个数组的首地址，只要看malloc函数中参数size 的距离内容。我们这里malloc分配的内存空间在逻辑上连续的，而在物理上可以连续也可以不连续。对于我们程序员来说，关注的是逻辑上的连续，因为操作系统会帮我们安排内存分配，所以我们使用起来就可以当做是连续的。

3.3 属性

new/delete是C++关键字，需要编译器支持。malloc/free是库函数，需要头文件支持c。

3.4 自定义类型

new会先调用operator new函数，申请足够的内存（通常底层使用malloc实现）。然后调用类型的构造函数，初始化成员变量，最后返回自定义类型指针。delete先调用析构函数，然后调用operator delete函数释放内存（通常底层使用free实现）。
​ malloc/free是库函数，只能动态的申请和释放内存，无法强制要求其做自定义类型对象构造和析构工作。

4. 重载

C++允许重载new/delete操作符，特别的，布局new的就不需要为对象分配内存，而是指定了一个地址作为内存起始区域，new在这段内存上为对象调用构造函数完成初始化工作，并返回此地址。而malloc不允许重载。