Pre-C + + 17:

因为即使您将结果包装在智能指针中，它也容易发生细微的泄漏。

考虑一个“小心”的用户，他记得在智能指针中包装对象:

foo(shared_ptr<T1>(new T1()), shared_ptr<T2>(new T2()));

这段代码很危险，因为不能保证在T1或T2之前构造shared_ptr。因此，如果新T1()或新T2()中的一个在另一个成功后失败，那么第一个对象将被泄露，因为不存在shared_ptr来销毁和释放它。

解决方法:使用make_shared。

Post-C + + 17:

这不再是一个问题:c++ 17对这些操作的顺序施加了约束，在这种情况下，确保每次调用new()必须立即构造相应的智能指针，中间没有其他操作。这意味着，在调用第二个new()时，可以保证第一个对象已经被包装在其智能指针中，从而防止在抛出异常时发生任何泄漏。

Barry在另一个回答中提供了关于c++ 17引入的新求值顺序的更详细的解释。

感谢@Remy Lebeau指出这在c++ 17中仍然是一个问题(尽管不是那么严重):shared_ptr构造函数可能无法分配它的控制块和抛出，在这种情况下，传递给它的指针不会被删除。

解决方法:使用make_shared。

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

Class var;

它被放置在堆栈上。

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

New在堆上分配对象。否则，对象分配在堆栈上。查一下两者的区别。

New()不应该尽可能少地使用。应该尽可能小心地使用它。而且，它应该在实用主义的要求下，在必要时经常使用。

对象在堆栈上的分配依赖于它们的隐式销毁，这是一个简单的模型。如果对象所需的作用域符合该模型，则不需要使用new()，以及相关的delete()和NULL指针检查。 在你有很多短期对象的情况下，在堆栈上分配应该可以减少堆碎片的问题。

但是，如果对象的生命周期需要扩展到当前范围之外，那么new()是正确的答案。只要确保您注意何时以及如何调用delete()以及NULL指针的可能性，使用已删除对象以及使用指针所带来的所有其他问题。

我倾向于不同意使用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.

在很大程度上，这是某人将自己的弱点提升为普遍准则。使用new操作符创建对象本身没有任何问题。有一些争论是，你必须遵循一些规则:如果你创建了一个对象，你需要确保它会被销毁。

最简单的方法是在自动存储中创建对象，这样c++就知道在它超出作用域时销毁它:

 {
    File foo = File("foo.dat");

    // Do things

 }

现在，观察一下，当你在结束大括号之后离开那个块时，foo超出了作用域。c++会自动调用它的析构函数。与Java不同，您不需要等待垃圾回收来找到它。

你写过

 {
     File * foo = new File("foo.dat");

你需要显式地匹配它

     delete foo;
  }

或者更好的是，将你的File *分配为“智能指针”。如果你不小心，它可能会导致泄漏。

答案本身做了一个错误的假设，如果你不使用new，你就不会在堆上分配;事实上，在c++中你不知道这一点。最多，您知道少量的内存，比如一个指针，肯定分配在堆栈上。但是，考虑一下File的实现是否像这样:

  class File {
    private:
      FileImpl * fd;
    public:
      File(String fn){ fd = new FileImpl(fn);}

然后FileImpl仍然会被分配到堆栈上。

是的，你最好确保你有

     ~File(){ delete fd ; }

在课堂上也是如此;如果没有它，即使根本没有在堆上分配内存，也会从堆中泄漏内存。