原因很复杂。

首先，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 */ }

明白了吗?

原因很复杂。

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

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

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

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

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

我发现有几个重要的原因让我们忽略了尽量少做新事情:

Operator new的执行时间不确定

调用new可能会导致操作系统为进程分配新的物理页，也可能不会。如果你经常这样做，会很慢。或者它可能已经准备好了一个合适的内存位置;我们不知道。如果你的程序需要具有一致且可预测的执行时间(如在实时系统或游戏/物理模拟中)，你需要避免在时间关键型循环中添加新的元素。

操作符new是一个隐式线程同步

是的，你听到了。你的操作系统需要确保你的页表是一致的，因此调用new会导致你的线程获得一个隐式互斥锁。如果你一直从许多线程调用new，你实际上是在序列化你的线程(我用32个cpu做过这个，每个cpu都调用new来获得几百个字节，哎呦!那是一个需要调试的皇家p.i.t.a.。)

其余的，比如速度慢、碎片化、容易出错等，其他答案已经提到了。

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

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

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

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

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

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

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

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

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

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

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

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