new和malloc的区别

参考博客（
作者：melonstreet
链接：https://www.cnblogs.com/QG-whz/p/5140930.html
）

1、申请内存的位置

new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。自由存储区是C++基于new操作符的一个抽象概念，凡是通过new操作符进行内存申请，该内存即为自由存储区。而堆是操作系统中的术语，是操作系统所维护的一块特殊内存，用于程序的内存动态分配，C语言使用malloc从堆上分配内存，使用free释放已分配的对应内存。

那么自由存储区是否能够是堆（问题等价于new是否能在堆上动态分配内存），这取决于operator new 的实现细节。

因为很多的编译器的new/delete都是以malloc/free为基础来实现的，所以，基本上所有的C++编译器都是默认使用堆来实现自由储存的，也就是说，默认的全局运算符new和delete也许会使用malloc和free的方式申请和释放空间，也就是说自由储存区就位于堆上，但是我们可以通过重载new，改用其他内存来实现自由储存，例如全局变量做的对象池，这是自由存储区就不位于堆上。

自由存储区和堆的区别是：堆是操作系统维护的一块内存，是一个物理概念，而自由存储是C++中通过new与delete动态分配和释放的对象的存储区，是一个逻辑概念，自由储存区可以使堆，也可以不是。

特别的，new甚至可以不为对象分配内存！定位new的功能可以办到这一点：

new (place_address) type

place_address为一个指针，代表一块内存的地址。当使用上面这种仅以一个地址调用new操作符时，new操作符调用特殊的operator new，也就是下面这个版本：

void * operator new (size_t,void *) //不允许重定义这个版本的operator new

这个operator new不分配任何的内存，它只是简单地返回指针实参，然后右new表达式负责在place_address指定的地址进行对象的初始化工作

2、返回类型的安全性

new操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，不需要再进行类型转换。

//举例
A *a = new A;
free(a);

而malloc内存分配成功返回的则是void*，需要进行强制类型转换。

//malloc源码
void *
__libc_malloc (size_t bytes)
{}

类型安全很大程度上可以等价于内存安全，类型安全的代码不会试图方法自己没被授权的内存区域。关于C++的类型安全性可说的又有很多了 。

3、内存分配失败时的返回值

new内存分配失败时，会抛出bac_alloc异常，它不会返回NULL；malloc分配内存失败时返回NULL。

//malloc举例
int * a = (int*) malloc(sizeof(int));
if(NULL == a)
{}
else
{}
//new举例
try
{
    int *a = new int();
}
catch (bad_alloc)
{
}

4、是否需要指定内存大小

使用new操作符申请内存分配时无须指定内存块的大小，编译器会根据类型信息自行计算，而malloc则需要显式地指出所需内存的尺寸。

//new举例
class A{};
A* aNew = new A;
A* aMalloc = (A*)malloc(sizeof(A)); //需要显式指定所需内存大小sizeof(A);

5、是否调用构造函数/析构函数

使用new操作符来分配对象内存时会经历三个步骤：

• 第一步：调用operator new 函数（对于数组是operator new[]）分配一块足够大的，原始的，未命名的内存空间以便存储特定类型的对象。
• 第二步：编译器运行相应的构造函数以构造对象，并为其传入初值。
• 第三部：对象构造完成后，返回一个指向该对象的指针。

使用delete操作符来释放对象内存时会经历两个步骤：

• 第一步：调用对象的析构函数。
• 第二步：编译器调用operator delete(或operator delete[])函数释放内存空间。

总之来说，new/delete会调用对象的构造函数/析构函数以完成对象的构造/析构。而malloc则不会。

class A
{
public:
    A(){cout<<"init class A"<<endl;}
	~A(){cout<<"delete class A"<<endl;}
};
int main()
{
    A * a = (A*)malloc(sizeof(A));
    free(a)
    return 0;
}

可以看出类A的构造函数和析构函数并没有被调用。所以定义类对象的时候一定要用new/delete

6、对数组的处理

C++提供了new[]与delete[]来专门处理数组类型:

class A
{
public:
    A(){cout<<"init class A"<<endl;}
	~A(){cout<<"delete class A"<<endl;}
};
A* bufferA = new A[10];//一次申请10个A数组内存；
delete []bufferA;

new对数组的支持体现在它会分别调用构造函数函数初始化每一个数组元素，释放对象时为每个对象调用析构函数。注意delete[]要与new[]配套使用，不然会找出数组对象部分释放的现象，造成内存泄漏。

至于malloc，不管你申请的是什么用来干什么，直接就给你申请好一块内存，返回一个指针。

int * bufferPtr = (int *) malloc( sizeof(int)* 10 );//分配一个10个int元素的数组

7、new与malloc是否可以相互调用

operator new /operator delete的实现可以基于malloc，而malloc的实现不可以去调用new。下面是编写operator new /operator delete 的一种简单方式，其他版本也与之类似：

void * operator new (sieze_t size)
{
    if(void * mem = malloc(size)
        return mem;
    else
        throw bad_alloc();
}
void operator delete(void *mem) noexcept
{
    free(mem);
}

8、是否可以被重载

opeartor new /operator delete可以被重载。标准库是定义了operator new函数和operator delete函数的8个重载版本：

//这些版本可能抛出异常
void * operator new(size_t);
void * operator new[](size_t);
void * operator delete (void * )noexcept;
void * operator delete[](void *0）noexcept;
//这些版本承诺不抛出异常
void * operator new(size_t ,nothrow_t&) noexcept;
void * operator new[](size_t, nothrow_t& );
void * operator delete (void *,nothrow_t& )noexcept;
void * operator delete[](void *0,nothrow_t& ）noexcept;

我们可以自定义上面函数版本中的任意一个，前提是自定义版本必须位于全局作用域或者类作用域中。太细节的东西不在这里讲述，总之，我们知道我们有足够的自由去重载operator new /operator delete ,以决定我们的new与delete如何为对象分配内存，如何回收对象。

而malloc/free并不允许重载。

9、能够直观地重新分配内存

使用malloc分配的内存后，如果在使用过程中发现内存不足，可以使用realloc函数进行内存重新分配实现内存的扩充。realloc先判断当前的指针所指内存是否有足够的连续空间，如果有，原地扩大可分配的内存地址，并且返回原来的地址指针；如果空间不够，先按照新指定的大小分配空间，将原有数据从头到尾拷贝到新分配的内存区域，而后释放原来的内存区域。

void *realloc(void *ptr, size_t size){}
/*
    ptr -- 指针指向一个要重新分配内存的内存块，该内存块之前是通过调用 malloc、calloc 或 realloc 进行分配内存的。如果为空指针，则会分配一个新的内存块，且函数返回一个指向它的指针。
    size -- 内存块的新的大小，以字节为单位。如果大小为 0，且 ptr 指向一个已存在的内存块，则 ptr 所指向的内存块会被释放，并返回一个空指针。
    该函数返回一个指针 ，指向重新分配大小的内存。如果请求失败，则返回 NULL。
*/
//举例
char* str = (char*)malloc(15);
str = (char*)realloc(str,25);

new没有这样直观的配套设施来扩充内存。

10、客户处理内存分配不足

在operator new抛出异常以反映一个未获得满足的需求之前，它会先调用一个用户指定的错误处理函数，这就是new-handler。new_handler是一个指针类型

namespace std
{
    typedef void (*new_handler)();
}

指向了一个没有参数没有返回值的函数,即为错误处理函数。为了指定错误处理函数，客户需要调用set_new_handler，这是一个声明于的一个标准库函数:

namespace std
{
    new_handler set_new_handler(new_handler p ) throw();
}

set_new_handler的参数为new_handler指针，指向了operator new 无法分配足够内存时该调用的函数。其返回值也是个指针，指向set_new_handler被调用前正在执行（但马上就要发生替换）的那个new_handler函数。

对于malloc，客户并不能够去编程决定内存不足以分配时要干什么事，只能看着malloc返回NULL。

区别点	new/delete	malloc/free
分配内存的位置	自由储存区（抽象概念）	堆（操作系统物理概念）
内存分配成功的返回值	类型指针	void*
内存分配失败的返回值	默认抛出异常bad_alloc	NULL
分配内存的大小	由编译器根据类型计算也可指定	必须显示指定内存大小
调用类构造和析构函数	可以	不能
处理数组	有专门的new[]	需要显示指定数组内存大小再用malloc分配
是否可以相互调用	可以，看具体的operator new/delete实现	不能调用new
是否可以被重载	可以	不行
能够直观地重新分配内存	不行	用relloc
客户处理内存分配不足	客户能够指定处理函数或重新制定分配器	无法通过用户代码进行处理