有几件事是new做的，malloc没有:

New通过调用该对象的构造函数来构造该对象 New不需要对已分配的内存进行类型转换。 它不需要分配大量的内存，而是需要大量的内存 要构造的对象。

因此，如果使用malloc，则需要显式地执行上述操作，这并不总是实际的。此外，new可以重载，但malloc不能。

如果你处理的数据不需要构造/销毁，需要重新分配(例如，一个大的整数数组)，那么我相信malloc/free是一个很好的选择，因为它给你realloc，这比new-memcpy-delete快得多(它在我的Linux盒子上，但我猜这可能是平台相关的)。如果你使用的c++对象不是POD并且需要构造/销毁，那么你必须使用new和delete操作符。

无论如何，如果可以利用realloc可以给您的速度提升(如果您正在重新分配大型POD数组，有时是一个显著的提升)，我不明白为什么不应该同时使用这两种方法(前提是您释放了错误的内存并删除了用new分配的对象)。

除非你需要它，否则你应该坚持在c++中使用new/delete。

New vs malloc()

1) new是操作符，malloc()是函数。

2) new调用构造函数，而malloc()不调用。

3) new返回准确的数据类型，而malloc()返回void *。

4) new从不返回NULL(失败时会抛出)，而malloc()返回NULL

5)重新分配内存不能由new处理，而malloc()可以

除非被迫使用C，否则永远不要使用malloc。总是使用new。

如果你需要大量的数据，可以这样做:

char *pBuffer = new char[1024];

尽管这是不正确的，但要小心:

//This is incorrect - may delete only one element, may corrupt the heap, or worse...
delete pBuffer;

相反，你应该在删除数据数组时这样做:

//This deletes all items in the array
delete[] pBuffer;

new关键字是c++实现它的方式，它将确保你的类型的构造函数被调用。new关键字也更加类型安全，而malloc根本不是类型安全的。

我认为使用malloc有益的唯一方式是需要改变数据缓冲区的大小。new关键字没有类似realloc的方式。realloc函数可能能够更有效地扩展内存块的大小。

值得一提的是，你不能将new/free和malloc/delete混合使用。

注:本题部分答案无效。

int* p_scalar = new int(5);  // Does not create 5 elements, but initializes to 5
int* p_array  = new int[5];  // Creates 5 elements

只使用malloc和free来分配将由以c为中心的库和api管理的内存。对你控制的所有东西使用new和delete(以及[]变量)。

只有当对象的生命周期与创建它的作用域不同时才需要动态分配(这也适用于使作用域变小或变大)，并且您有特定的原因按值存储它不起作用。

例如:

 std::vector<int> *createVector(); // Bad
 std::vector<int> createVector();  // Good

 auto v = new std::vector<int>(); // Bad
 auto result = calculate(/*optional output = */ v);
 auto v = std::vector<int>(); // Good
 auto result = calculate(/*optional output = */ &v);

从c++ 11开始，我们有std::unique_ptr来处理已分配的内存，它包含已分配内存的所有权。Std::shared_ptr是为必须共享所有权而创建的。(你需要的比你在一个好的程序中期望的要少)

创建一个实例变得非常简单:

auto instance = std::make_unique<Class>(/*args*/); // C++14
auto instance = std::unique_ptr<Class>(new Class(/*args*/)); // C++11
auto instance = std::make_unique<Class[]>(42); // C++14
auto instance = std::unique_ptr<Class[]>(new Class[](42)); // C++11

c++ 17还增加了std::optional，这可以防止你需要内存分配

auto optInstance = std::optional<Class>{};
if (condition)
    optInstance = Class{};

一旦'instance'超出作用域，内存就会被清理。转让所有权也很容易:

 auto vector = std::vector<std::unique_ptr<Interface>>{};
 auto instance = std::make_unique<Class>();
 vector.push_back(std::move(instance)); // std::move -> transfer (most of the time)

那你什么时候还需要新的?从c++ 11开始几乎没有。大多数情况下你使用std::make_unique，直到你遇到一个通过原始指针转移所有权的API。

 auto instance = std::make_unique<Class>();
 legacyFunction(instance.release()); // Ownership being transferred

 auto instance = std::unique_ptr<Class>{legacyFunction()}; // Ownership being captured in unique_ptr

在c++ 98/03中，您必须进行手动内存管理。如果您是这种情况，请尝试升级到标准的最新版本。如果你被卡住了:

 auto instance = new Class(); // Allocate memory
 delete instance;             // Deallocate
 auto instances = new Class[42](); // Allocate memory
 delete[] instances;               // Deallocate

确保正确跟踪所有权，以免出现内存泄漏!Move语义也不能工作。

那么，在c++中什么时候需要malloc呢?唯一有效的原因是分配内存并在以后通过放置new初始化它。

 auto instanceBlob = std::malloc(sizeof(Class)); // Allocate memory
 auto instance = new(instanceBlob)Class{}; // Initialize via constructor
 instance.~Class(); // Destroy via destructor
 std::free(instanceBlob); // Deallocate the memory

尽管如此，上面的操作是有效的，这也可以通过new操作符来完成。vector就是一个很好的例子。

最后，我们仍然有一个房间里的大象:C。如果你必须使用一个在c++代码中分配内存并在C代码中释放内存的C库(或者相反)，你就被迫使用malloc/free。

如果你是在这种情况下，忘记虚函数、成员函数、类……只有包含pod的结构才被允许。

规则的一些例外情况:

您正在编写一个具有高级数据结构的标准库，其中malloc是合适的 你必须分配大量的内存(在10GB文件的内存副本中?) 您拥有阻止您使用某些构造的工具 您需要存储不完整的类型