新就是新目标。

Recall why goto is so reviled: while it is a powerful, low-level tool for flow control, people often used it in unnecessarily complicated ways that made code difficult to follow. Furthermore, the most useful and easiest to read patterns were encoded in structured programming statements (e.g. for or while); the ultimate effect is that the code where goto is the appropriate way to is rather rare, if you are tempted to write goto, you're probably doing things badly (unless you really know what you're doing).

New也类似——它经常被用来使事情变得不必要的复杂和难以阅读，最有用的使用模式可以被编码到各种各样的类中。此外，如果您需要使用任何新的使用模式，而这些模式还没有标准类，您可以编写自己的类来编码它们!

我甚至认为new比goto更糟糕，因为需要对new和delete语句进行配对。

像goto一样，如果您认为需要使用new，那么您可能做得很糟糕——特别是如果您在一个类的实现之外这样做，这个类的目的是封装您需要做的任何动态分配。

核心原因是堆上的对象总是比简单值更难使用和管理。编写易于阅读和维护的代码始终是任何认真的程序员的首要任务。

另一种情况是，我们使用的库提供了值语义，使动态分配变得不必要。Std::string就是一个很好的例子。

然而，对于面向对象的代码，使用指针——这意味着使用new来预先创建指针——是必须的。为了简化资源管理的复杂性，我们有几十种工具使其尽可能简单，比如智能指针。基于对象的范式或泛型范式假设值语义，并需要更少或不需要新的，正如其他地方的海报所述。

传统的设计模式，尤其是GoF书中提到的那些，大量使用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 */ }

明白了吗?

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

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

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

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

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

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

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

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

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

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

有两种广泛使用的内存分配技术:自动分配和动态分配。通常，每个对象都有相应的内存区域:堆栈和堆。

堆栈

堆栈总是按顺序分配内存。它可以这样做，因为它要求您以相反的顺序释放内存(先入，后出:FILO)。这是许多编程语言中局部变量的内存分配技术。它非常非常快，因为它需要最少的簿记，并且下一个要分配的地址是隐式的。

在c++中，这被称为自动存储，因为存储是在作用域结束时自动声明的。一旦当前代码块(使用{}分隔)的执行完成，该代码块中所有变量的内存将被自动收集。这也是调用析构函数来清理资源的时刻。

Heap

堆支持更灵活的内存分配模式。记账更复杂，分配更慢。因为没有隐式释放点，你必须手动释放内存，使用delete或delete[] (C中的free)。然而，没有隐式释放点是堆灵活性的关键。

使用动态分配的原因

即使使用堆速度较慢，并可能导致内存泄漏或内存碎片，动态分配也有很好的用例，因为它的限制较少。

使用动态分配的两个关键原因:

You don't know how much memory you need at compile time. For instance, when reading a text file into a string, you usually don't know what size the file has, so you can't decide how much memory to allocate until you run the program. You want to allocate memory which will persist after leaving the current block. For instance, you may want to write a function string readfile(string path) that returns the contents of a file. In this case, even if the stack could hold the entire file contents, you could not return from a function and keep the allocated memory block.

为什么动态分配往往是不必要的

在c++中，有一个简洁的构造叫做析构函数。这种机制允许您通过将资源的生命周期与变量的生命周期对齐来管理资源。这种技术被称为RAII，是c++的特点。它将资源“包装”到对象中。Std::string就是一个很好的例子。这个代码片段:

int main ( int argc, char* argv[] )
{
    std::string program(argv[0]);
}

实际上分配的内存是可变的。string对象使用堆分配内存，并在析构函数中释放内存。在这种情况下，您不需要手动管理任何资源，仍然可以获得动态内存分配的好处。

特别地，它在这段代码中暗示:

int main ( int argc, char* argv[] )
{
    std::string * program = new std::string(argv[0]);  // Bad!
    delete program;
}

存在不需要的动态内存分配。该程序需要更多的输入(!)，并引入了忘记释放内存的风险。这样做没有明显的好处。

为什么你应该尽可能多地使用自动存储

基本上，最后一段总结了一下。尽可能多地使用自动存储会使你的程序:

打字更快; 跑起来更快; 不容易发生内存/资源泄漏。

加分

在引用的问题中，还有其他的关注点。特别是下面的类:

class Line {
public:
    Line();
    ~Line();
    std::string* mString;
};

Line::Line() {
    mString = new std::string("foo_bar");
}

Line::~Line() {
    delete mString;
}

实际上比下面这个更有风险:

class Line {
public:
    Line();
    std::string mString;
};

Line::Line() {
    mString = "foo_bar";
    // note: there is a cleaner way to write this.
}

原因是std::string正确地定义了一个复制构造函数。考虑下面的程序:

int main ()
{
    Line l1;
    Line l2 = l1;
}

使用原始版本，这个程序可能会崩溃，因为它对同一个字符串使用了两次delete。使用修改后的版本，每个Line实例将拥有自己的字符串实例，每个实例都有自己的内存，并且都将在程序结束时释放。

其他的笔记

由于上述原因，RAII的广泛使用被认为是c++中的最佳实践。然而，还有一个不太明显的额外好处。基本上，它比各个部分的和要好。整个机构组成。这尺度。

如果你使用Line类作为构建块:

 class Table
 {
      Line borders[4];
 };

Then

 int main ()
 {
     Table table;
 }

分配四个std::string实例，四个Line实例，一个Table实例和所有字符串的内容，所有的东西都会自动释放。