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

Class var;

它被放置在堆栈上。

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

我倾向于不同意使用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在堆上分配对象。否则，对象分配在堆栈上。查一下两者的区别。

在很大程度上，这是某人将自己的弱点提升为普遍准则。使用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 ; }

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

C++ doesn't employ any memory manager by its own. Other languages like C# and Java have a garbage collector to handle the memory C++ implementations typically use operating system routines to allocate the memory and too much new/delete could fragment the available memory With any application, if the memory is frequently being used it's advisable to preallocate it and release when not required. Improper memory management could lead memory leaks and it's really hard to track. So using stack objects within the scope of function is a proven technique The downside of using stack objects are, it creates multiple copies of objects on returning, passing to functions, etc. However, smart compilers are well aware of these situations and they've been optimized well for performance It's really tedious in C++ if the memory being allocated and released in two different places. The responsibility for release is always a question and mostly we rely on some commonly accessible pointers, stack objects (maximum possible) and techniques like auto_ptr (RAII objects) The best thing is that, you've control over the memory and the worst thing is that you will not have any control over the memory if we employ an improper memory management for the application. The crashes caused due to memory corruptions are the nastiest and hard to trace.

我想海报的意思是，你不必把所有的东西都分配到堆上，而不是堆栈上。

基本上，对象是在堆栈上分配的(当然，如果对象大小允许的话)，因为堆栈分配的成本较低，而不是基于堆的分配，后者涉及分配器的大量工作，并增加了冗长的内容，因为这样您就必须管理分配在堆上的数据。