一.c++中new的三种使用方法包括：plain new， nothrow new 和 placement new。

      1. plain new 就是我们最常使用的new的方式，在C++中的定义如下：

    1.1 void* operator new(std::size_t) throw(std::bad_alloc);

    1.2  void operator delete( void *) throw();

          plain new在分配失败的情况下，抛出异常std::bad_alloc而不是返回NULL。

 

      2. nothrow new 是不抛出异常的运算符new的形式。nothrow new在失败时，返回NULL。定义如下：

       2.1 void * operator new(std::size_t, const std::nothrow_t&) throw();

       2.2 void operator delete(void*) throw();

   

 3. placement new 意即“放置”，这种new允许在一块已经分配成功的内存上重新构造对象或对象数组。placement new不用担心内存分配失败，因为它根本不分配内存，它做的唯一一件事情就是调用对象的构造函数。定义如下：

      3.1 void* operator new(size_t, void*);

     3.2 void operator delete(void*, void*);

palcement new 的主要用途就是反复使用已分配的内存，避免多次分配的开销和风险。

 

二.malloc的用法

       1.概念

                 ‌malloc函数‌在C语言中用于动态分配内存。其全称是memory allocation，用于申请一块连续的指定大小的内存块区域，并以void*类型返回分配的内存区域地址。malloc函数的原型为：

                 void *malloc(unsigned int size);

               该函数在内存的动态存储区中分配一个长度为size的连续空间。如果分配成功，则返回指向被分配内存的指针；如果分配失败，则返回空指针NULL。malloc函数返回的指针需要通过类型转换才能用于具体的数据对象。

1. ‌分配内存‌：使用malloc函数分配指定大小的内存块。例如，分配100个字节的内存：

int *ptr = (int*)malloc(100 * sizeof(int));

三. new和malloc的区别

1. 申请的内存所在位置

　　new操作符从自由存储区（free store）上为对象动态分配内存空间，而malloc函数从堆上动态分配内存。

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

　　那么自由存储区是否能够是堆（问题等价于new是否能在堆上动态分配内存），这取决于operator new 的实现细节。自由存储区不仅可以是堆，还可以是静态存储区，这都看operator new在哪里为对象分配内存。

　　特别的，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操作符内存分配成功时，返回的是对象类型的指针，类型严格与对象匹配，无须进行类型转换，故new是符合类型安全性的操作符。而malloc内存分配成功则是返回void * ，需要通过强制类型转换将void*指针转换成我们需要的类型。

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

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

　　在使用C语言时，我们习惯在malloc分配内存后判断分配是否成功：示例如下：

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

if(NULL == a){

…

}

else

{

  ...

}

　c++中正确的做法应该是使用异常机制：

try

{

  int *a = new int();

}catch (bad_alloc &obj)

{  

    ...

}

 

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

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

class Demo{...

 

};

 

int main()

{

    Demo * ptr = new Demo ;

Demo * ptr = (Demo *)malloc(sizeof(Demo )); //需要显式指定所需内存大小sizeof(Demo );

}

 

　　当然了，我这里使用malloc来为我们自定义类型分配内存是不怎么合适的，请看下一条。

 

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

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

　　第一步：调用operator new 函数（对于数组是operator new[]）分配一块足够大的，原始的，未命名的内存空间以便存储特定类型的对象。

　　第二步：编译器运行相应的构造函数以构造对象，并为其传入初值。

　　第三部：对象构造完成后，返回一个指向该对象的指针。

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

　　第一步：调用对象的析构函数。

　　第二步：编译器调用operator delete(或operator delete[])函数释放内存空间。

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

class Demo

{

 

public:

    Demo() :a(1), b(1.2)

    {

        cout << __LINE__ << ":" << __func__ << endl;

    }

 

private:  

 

   int a;

    double b;

};

 

int main()

 

{

 

  Demo * ptr = (Demo*)malloc(sizeof(Demo)); //构造函数没有调用

 

   return 0;

 

}

 

 

而使用new来分配对象时，示例如下:

class Demo

{                                                      

public:

    Demo() :a(1), b(1.2)

    {   

        cout << a << ":" << b << endl;

    }   

 

private:

    int a;

    double b;

};

 

int main()

{

    Demo * ptr = new Demo;

    return 0;

}

6.对数组的处理

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

      A * ptr = new A[10];//分配10个A对象

 

　　使用new[]分配的内存必须使用delete[]进行释放：

      delete [] ptr;

 

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

　　至于malloc，它并知道你在这块内存上要放的数组还是啥别的东西，反正它就给你一块原始的内存，在给你个内存的地址就完事。所以如果要动态分配一个数组的内存，还需要我们手动指定数组的大小：

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

 

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

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

1. void * operator new (sieze_t size)

2. {

3.     if(void * mem = malloc(size)

4.         return mem;

5.     else

6.         throw bad_alloc();

7. }

8. void operator delete(void *mem) noexcept

9. {

10.       free(mem);

11. }

 

8.是否可以被重载

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

//这些版本可能抛出异常

1. void * operator new(size_t);

2. void * operator new[](size_t);

3. void * operator delete (void * )noexcept;

4. void * operator delete[](void *0）noexcept;

//这些版本承诺不抛出异常

5. void * operator new(size_t ,nothrow_t&) noexcept;

6. void * operator new[](size_t, nothrow_t& );

7. void * operator delete (void *,nothrow_t& )noexcept;

8. void * operator delete[](void *0,nothrow_t& ）noexcept;

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

　　而malloc/free并不允许重载。

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

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

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

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

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

1. namespace std

2. {

3. typedef void (*new_handler)();

4. }

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

1. namespace std

2. {

3.     new_handler set_new_handler(new_handler p ) throw();

4. }

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

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

总结

　　将上面所述的10点差别整理成表格：