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

例如:

 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文件的内存副本中?) 您拥有阻止您使用某些构造的工具 您需要存储不完整的类型

来自c++ FQA Lite:

[16.4] Why should I use new instead of trustworthy old malloc()? FAQ: new/delete call the constructor/destructor; new is type safe, malloc is not; new can be overridden by a class. FQA: The virtues of new mentioned by the FAQ are not virtues, because constructors, destructors, and operator overloading are garbage (see what happens when you have no garbage collection?), and the type safety issue is really tiny here (normally you have to cast the void* returned by malloc to the right pointer type to assign it to a typed pointer variable, which may be annoying, but far from "unsafe"). Oh, and using trustworthy old malloc makes it possible to use the equally trustworthy & old realloc. Too bad we don't have a shiny new operator renew or something. Still, new is not bad enough to justify a deviation from the common style used throughout a language, even when the language is C++. In particular, classes with non-trivial constructors will misbehave in fatal ways if you simply malloc the objects. So why not use new throughout the code? People rarely overload operator new, so it probably won't get in your way too much. And if they do overload new, you can always ask them to stop.

对不起，我就是忍不住。：）

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

例如:

 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文件的内存副本中?) 您拥有阻止您使用某些构造的工具 您需要存储不完整的类型

如果你正在使用c++，尝试使用new/delete而不是malloc/calloc，因为它们是操作符。对于malloc/calloc，需要包含另一个头文件。不要在同一代码中混合使用两种不同的语言。它们的工作在各个方面都是相似的，都是从哈希表的堆段动态分配内存。

New将初始化结构的默认值，并正确地将结构中的引用链接到结构本身。

E.g.

struct test_s {
    int some_strange_name = 1;
    int &easy = some_strange_name;
}

因此，new struct test_s将返回一个带有工作引用的初始化结构，而malloc'ed版本没有默认值，实习引用也没有初始化。

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

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

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