由new创建的对象必须最终删除，以免泄漏。析构函数不会被调用，内存不会被释放，整个比特。由于c++没有垃圾收集，这是一个问题。

由值创建的对象(即在堆栈上)在超出作用域时自动死亡。析构函数调用由编译器插入，并且在函数返回时自动释放内存。

像unique_ptr、shared_ptr这样的智能指针解决了悬空引用问题，但它们需要编码规则，并有其他潜在的问题(可复制性、引用循环等)。

此外，在大量多线程的场景中，new是线程之间的争用点;过度使用new可能会影响性能。堆栈对象的创建根据定义是线程本地的，因为每个线程都有自己的堆栈。

值对象的缺点是，一旦宿主函数返回，它们就会死亡——你不能将它们的引用传递给调用者，只能通过复制、返回或按值移动。

我倾向于不同意使用new“too much”的观点。尽管最初的海报使用new with system classes有点可笑。(int *我;I = new int[9999];?真的吗?int [9999];这样就清楚多了。)我想这就是让评论者生气的地方。

When you're working with system objects, it's very rare that you'd need more than one reference to the exact same object. As long as the value is the same, that's all that matters. And system objects don't typically take up much space in memory. (one byte per character, in a string). And if they do, the libraries should be designed to take that memory management into account (if they're written well). In these cases, (all but one or two of the news in his code), new is practically pointless and only serves to introduce confusions and potential for bugs.

When you're working with your own classes/objects, however (e.g. the original poster's Line class), then you have to begin thinking about the issues like memory footprint, persistence of data, etc. yourself. At this point, allowing multiple references to the same value is invaluable - it allows for constructs like linked lists, dictionaries, and graphs, where multiple variables need to not only have the same value, but reference the exact same object in memory. However, the Line class doesn't have any of those requirements. So the original poster's code actually has absolutely no needs for new.

原因很复杂。

首先，c++不进行垃圾收集。因此，对于每一个new，必须有一个对应的delete。如果您没有将此删除，那么您就有内存泄漏。现在，对于这样一个简单的例子:

std::string *someString = new std::string(...);
//Do stuff
delete someString;

这很简单。但是如果“Do stuff”抛出异常会发生什么?哎呀:内存泄漏。如果“做事情”问题提前回归会发生什么?哎呀:内存泄漏。

这是最简单的情况。如果你碰巧将这个字符串返回给某人，现在他们必须删除它。如果他们把它作为参数传递，接收它的人需要删除它吗?什么时候删除?

或者，你可以这样做:

std::string someString(...);
//Do stuff

没有删除。对象是在“堆栈”上创建的，一旦超出作用域就会被销毁。您甚至可以返回对象，从而将其内容传递给调用函数。你可以将对象传递给函数(通常作为引用或const-reference: void SomeFunc(std::string &iCanModifyThis, const std::string &iCantModifyThis)。等等。

全部不需要new和delete。不存在谁拥有内存或谁负责删除它的问题。如果你有:

std::string someString(...);
std::string otherString;
otherString = someString;

可以理解为otherString拥有someString数据的副本。它不是指针;它是一个单独的对象。它们可能碰巧具有相同的内容，但你可以在不影响另一个的情况下更改其中一个:

someString += "More text.";
if(otherString == someString) { /*Will never get here */ }

明白了吗?

使用new时，对象被分配到堆中。它通常用于预期扩展时。当你声明一个对象，比如，

Class var;

它被放置在堆栈上。

你总是需要对你用new放在堆上的对象调用destroy。这就有可能导致内存泄漏。放在堆栈上的对象不容易发生内存泄漏!

许多答案都涉及到各种性能考虑因素。我想解决让OP困惑的评论:

不要像Java程序员那样思考。

事实上，在Java中，正如这个问题的答案所解释的那样，

第一次显式创建对象时使用new关键字。

但在c++中，类型为T的对象是这样创建的:T{}(或T{ctor_argument1,ctor_arg2}对于带参数的构造函数)。这就是为什么通常你没有理由想要使用new。

那么，为什么要用它呢?有两个原因:

您需要创建许多值，这些值的数量在编译时是未知的。 由于c++实现在普通机器上的限制-通过分配太多空间来防止堆栈溢出，以常规方式创建值。

现在，除了你引用的评论暗示的内容之外，你应该注意到，即使是上面的两种情况也已经涵盖得很好了，而不必“求助”使用新的自己:

您可以使用来自标准库的容器类型，它们可以保存运行时可变数量的元素(如std::vector)。 您可以使用智能指针，它为您提供一个类似于new的指针，但确保在“指针”超出作用域的地方释放内存。

因此，在c++社区编码指南中，避免显式的new和delete是一个正式的条款:指南R.11。

以上所有正确答案还有一点，这取决于你在做什么类型的编程。在Windows中开发内核，例如->堆栈受到严重限制，您可能无法像在用户模式中那样处理页面错误。

在这样的环境中，新的或类似c的API调用是首选的，甚至是必需的。

当然，这只是规则的一个例外。