328

我使用 C++ 有一段时间了，我一直想知道这个new关键字。简单地说，我应该使用它，还是不使用它？

  1. 用new关键字...
    MyClass* myClass = new MyClass();
    myClass->MyField = "Hello world!";
  1. 没有new关键字...
    MyClass myClass;
    myClass.MyField = "Hello world!";

从实现的角度来看，它们似乎没有什么不同（但我确信它们是不同的）......但是，我的主要语言是 C#，当然第一种方法是我习惯的。

困难似乎在于方法 1 更难与 std C++ 类一起使用。

我应该使用哪种方法？

更新1：

我最近对超出范围（即从函数返回）的大型数组使用了堆内存（或空闲存储new）关键字。在我使用堆栈之前，这会导致一半元素在范围之外损坏，切换到堆使用可确保元素完好无损。耶！

更新 2：

我的一个朋友最近告诉我，使用new关键字有一个简单的规则；每次键入时new，键入delete。

    Foobar *foobar = new Foobar();
    delete foobar; // TODO: Move this to the right place.

这有助于防止内存泄漏，因为您总是必须将删除放在某处（即，当您将其剪切并粘贴到析构函数或其他位置时）。

4

11 回答 11

352

方法 1（使用new）

  • 为空闲存储上的对象分配内存 （这通常与堆相同）
  • 需要您delete稍后明确您的对象。（如果你不删除它，你可能会造成内存泄漏）
  • 内存一直分配，直到你delete它。（即您可以return使用创建的对象new）
  • 除非指针为d，否则问题中的示例将泄漏内存；delete并且应该始终删除它，无论采用哪个控制路径，或者是否抛出异常。

方法2（不使用new）

  • 为堆栈上的对象分配内存（所有局部变量所在的地方）堆栈可用的内存通常较少；如果你分配了太多的对象，你就有堆栈溢出的风险。
  • 以后你就不需要了delete。
  • 超出范围时不再分配内存。（即你不应该return指向堆栈上的对象）

至于使用哪一个；鉴于上述限制，您选择最适合您的方法。

一些简单的案例：

  • 如果您不想担心调用delete，（以及导致内存泄漏的可能性），您不应该使用new.
  • 如果您想从函数返回指向对象的指针，则必须使用new
于 2009-03-17T16:48:37.143 回答
127

两者之间有一个重要的区别。

未分配的所有内容都与newC# 中的值类型非常相似（人们经常说这些对象是在堆栈上分配的，这可能是最常见/最明显的情况，但并非总是如此）。更准确地说，未使用分配的对象new具有自动存储持续时间 分配的所有内容都new在堆上分配，并返回指向它的指针，就像 C# 中的引用类型一样。

在堆栈上分配的任何东西都必须有一个常量大小，在编译时确定（编译器必须正确设置堆栈指针，或者如果对象是另一个类的成员，它必须调整另一个类的大小） . 这就是 C# 中的数组是引用类型的原因。它们必须是，因为使用引用类型，我们可以在运行时决定请求多少内存。这同样适用于这里。只有具有恒定大小（可以在编译时确定的大小）的数组才能分配自动存储持续时间（在堆栈上）。必须在堆上分配动态大小的数组，方法是调用new.

（这就是与 C# 的任何相似性停止的地方）

现在，在堆栈上分配的任何东西都有“自动”存储持续时间（您实际上可以将变量声明auto为来自）

自动存储持续时间意味着它听起来像，变量的持续时间是自动处理的。相比之下，在堆上分配的任何东西都必须由您手动删除。这是一个例子：

void foo() {
  bar b;
  bar* b2 = new bar();
}

此函数创建三个值得考虑的值：

在第 1 行，它在堆栈上声明了一个b类型变量（自动持续时间）。bar

在第 2 行，它在堆栈上声明一个bar指针b2（自动持续时间），并调用 new，在堆上分配一个bar对象。（动态持续时间）

当函数返回时，会发生以下情况：首先，b2超出范围（破坏顺序总是与构造顺序相反）。但是b2只是一个指针，所以什么也没有发生，它占用的内存被简单地释放了。重要的是，它指向的内存（bar堆上的实例）没有被触及。只有指针被释放，因为只有指针具有自动持续时间。其次，b超出范围，因此由于它具有自动持续时间，因此调用其析构函数并释放内存。

堆上的bar实例呢？它可能还在那里。没有人愿意删除它，所以我们泄露了内存。

从这个例子中，我们可以看到任何具有自动持续时间的东西都保证在超出范围时调用其析构函数。这很有用。但是在堆上分配的任何东西只要我们需要它就可以持续，并且可以动态调整大小，就像数组一样。这也很有用。我们可以使用它来管理我们的内存分配。如果 Foo 类在其构造函数中在堆上分配一些内存，并在其析构函数中删除该内存会怎样。然后我们可以两全其美，保证再次释放的安全内存分配，但没有强制所有内容都在堆栈上的限制。

这几乎就是大多数 C++ 代码的工作方式。以标准库std::vector为例。这通常在堆栈上分配，但可以动态调整大小和调整大小。它通过在必要时在堆上内部分配内存来做到这一点。该类的用户永远不会看到这一点，因此不会泄漏内存或忘记清理您分配的内容。

这个原理叫做RAII（Resource Acquisition is Initialization），它可以扩展到任何必须被获取和释放的资源。（网络套接字、文件、数据库连接、同步锁）。它们都可以在构造函数中获取，并在析构函数中释放，因此您可以保证您获得的所有资源都会再次被释放。

作为一般规则，永远不要直接从您的高级代码中使用 new/delete。始终将它包装在一个可以为您管理内存的类中，这将确保它再次被释放。（是的，这条规则可能有例外。特别是，智能指针要求您new直接调用，并将指针传递给其构造函数，然后由构造函数接管并确保delete正确调用。但这仍然是一个非常重要的经验法则)

于 2009-03-17T17:16:26.330 回答
20

简短的回答是：如果你是 C++ 的初学者，你永远不应该使用new或delete自己。

相反，您应该使用智能指针，例如std::unique_ptrand std::make_unique（或者不太常见的std::shared_ptrand std::make_shared）。这样，您几乎不必担心内存泄漏。即使您更高级，最佳实践通常是将您正在使用的自定义方式封装new到delete一个专门用于对象生命周期问题的小类（例如自定义智能指针）中。

当然，在幕后，这些智能指针仍在执行动态分配和释放，因此使用它们的代码仍然会产生相关的运行时开销。这里的其他答案已经涵盖了这些问题，以及如何就何时使用智能指针而不是仅在堆栈上创建对象或将它们合并为对象的直接成员做出设计决策，足够好，我不会重复它们。但我的执行摘要是：在某些事情迫使您使用之前，不要使用智能指针或动态分配。

于 2018-04-05T18:09:34.557 回答
14

我应该使用哪种方法？

这几乎从来不是由您的打字偏好决定的，而是由上下文决定的。如果您需要将对象保留在几个堆栈中，或者如果它对于堆栈来说太重，您可以将它分配到免费存储中。此外，由于您正在分配一个对象，因此您还负责释放内存。查找delete运算符。

为了减轻使用免费商店管理的负担，人们发明了类似auto_ptr和unique_ptr. 我强烈建议你看看这些。它们甚至可能对您的打字问题有所帮助；-)

于 2009-03-17T16:53:23.530 回答
11

如果您使用 C++ 编写代码，您可能是为了性能而编写代码。使用 new 和 free 存储比使用堆栈慢得多（尤其是在使用线程时），所以只在需要时使用它。

正如其他人所说，当您的对象需要位于函数或对象范围之外，对象非常大或者您在编译时不知道数组的大小时，您需要 new 。

另外，尽量避免使用删除。将你的 new 包装成一个智能指针。让智能指针为你调用 delete。

在某些情况下，智能指针不智能。永远不要将 std::auto_ptr<> 存储在 STL 容器中。由于容器内的复制操作，它将过早删除指针。另一种情况是当您有一个非常大的 STL 对象指针容器时。boost::shared_ptr<> 会产生大量的速度开销，因为它会上下颠簸引用计数。在这种情况下，更好的方法是将 STL 容器放入另一个对象中，并为该对象提供一个析构函数，该析构函数将对容器中的每个指针调用 delete。

于 2009-03-24T02:22:26.310 回答
2

简单的答案是肯定的 - new() 在堆上创建一个对象（不幸的副作用是您必须管理它的生命周期（通过显式调用它的 delete），而第二种形式在当前堆栈中创建一个对象范围，并且该对象将在超出范围时被销毁。

于 2009-03-17T16:48:10.220 回答
2

如果没有new关键字，您会将其存储在call stack上。在堆栈上存储过大的变量会导致堆栈溢出。

于 2009-03-17T16:51:13.363 回答
1

您是将 myClass 从函数中传递出来，还是期望它存在于该函数之外？正如其他人所说，当您不在堆上分配时，这完全与范围有关。当您离开该功能时，它会消失（最终）。初学者犯的经典错误之一是试图在函数中创建某个类的本地对象并返回它而不在堆上分配它。我记得在我早期使用 C++ 时调试过这种事情。

于 2009-03-17T16:57:17.997 回答
1

如果您的变量仅在单个函数的上下文中使用，则最好使用堆栈变量，即选项 2。正如其他人所说，您不必管理堆栈变量的生命周期 - 它们是构造和自动销毁。此外，相比之下，在堆上分配/释放变量很慢。如果您的函数被调用得足够频繁，那么如果使用堆栈变量与堆变量相比，您将看到巨大的性能提升。

也就是说，有几个明显的情况是堆栈变量不足。

如果堆栈变量具有较大的内存占用，那么您将面临堆栈溢出的风险。默认情况下，每个线程的堆栈大小在 Windows 上为 1 MB。您不太可能创建大小为 1 MB 的堆栈变量，但您必须记住堆栈利用率是累积的。如果您的函数调用一个函数，该函数调用另一个函数，该函数调用另一个函数......，所有这些函数中的堆栈变量都会占用同一个堆栈上的空间。递归函数会很快遇到这个问题，这取决于递归的深度。如果这是一个问题，您可以增加堆栈的大小（不推荐）或使用 new 运算符在堆上分配变量（推荐）。

另一个更可能的情况是您的变量需要“生存”在您的函数范围之外。在这种情况下，您将在堆上分配变量，以便可以在任何给定函数的范围之外访问它。

于 2009-03-17T17:09:28.593 回答
0

第二种方法在堆栈上创建实例，以及诸如声明的内容int和传递给函数的参数列表等内容。

第一种方法为堆栈上的指针腾出空间，您已将其设置为内存中MyClass已在堆上分配新的位置或空闲存储的位置。

第一种方法还要求您delete使用new.

于 2009-03-17T16:50:13.223 回答
-1

简短的回答是肯定的，“new”关键字非常重要，因为当您使用它时，对象数据存储在堆上而不是堆栈上，这是最重要的！

于 2009-03-17T16:47:48.333 回答