3

这很可能是一个非常愚蠢/基本的问题，但我无法弄清楚。我会告诉你我的想法 - 如果/我错了，请纠正我。

当我们使用 STL 容器来存储原始指针时，我们必须注意清理它们：

std::list<animal*> alist;
animal *a = new animal();
alist.push_back(a);
...
animal *b = alist.front();
alist.pop_front();
//do stuff with b
delete b;

如果我们存储对象会发生什么？我的理解是，如果一个装满对象的容器超出范围，则其中的所有对象都会被销毁。正确的？

但是如果我们从容器中移除一个对象，std::list<T>.pop_front()例如使用呢？

std::list<animal> alist;
{
  animal ani();
  //ani is inserted at the end of the list (it IS ani rather than a copy 
  //since push_back accepts const T&)
  alist.push_back(ani);
} //nothing is deallocated/destroyed here
...
{
  animal b = alist.front(); //b is now a copy(?!) of the front element
                            //created via copy constructor
  alist.pop_front(); //the front element of the list is 
                     //destroyed/destructor is called 
  //do stuff with b
} //b goes out of scope
4

5 回答 5

6

当您将某些内容存储在容器中时，您传递的任何内容都会被复制到容器1中。您仍然拥有原始对象2；容器拥有它的对象副本。确实push_back（例如）通过引用获取其参数。这意味着当您将要推送的对象传递到容器中时，不需要将副本用作参数本身，但放入容器中的内容仍然是您告诉它推送的内容的副本。引用传递意味着只需要一份；如果它是按值传递的（至少在 C++98/03 中），那将导致两个副本：从对象到函数参数的一个副本，然后从函数参数到容器的另一个副本。通过引用传递允许直接从原始对象直接复制到容器中。

同样，当您从容器中获取对象时，您将获得容器中内容的副本。容器仍然有它的对象，而你有你的对象。每一个都有自己的生命周期。

当您从容器中擦除或弹出一个对象时，该对象将从容器中删除并销毁——如果它具有析构函数，则将调用析构函数来销毁它。

当容器本身被销毁时，容器中的对象也将被销毁。您的对象将在碰巧被销毁时被销毁-它来自容器的事实对此没有影响。如果它是一个局部变量，它会在超出范围时被销毁。如果它是全球性的，它将持续到时间结束（对于程序）。如果您从函数中返回它并用于初始化引用，则将遵守延长其生命周期的正常规则。底线：在这一点上，它只是另一个对象，它将像以相同方式定义的任何其他对象一样具有生命周期。

当/如果您将指针（原始或智能）存储在容器中时，这可能会有点......模糊。以上所有内容实际上仍然正确，但是被复制/存储的对象是一个指针。除非您使用一些“知道”您正在存储指针的容器（例如，Boost ptr_vector），否则它只是在处理指针，并且“忽略”某个地方存在指针所指对象的事实。

  1. 例如，在 C++11 中，您可以使用emplace_back在容器中就地构造一个对象，但同样的基本思想也适用——容器拥有它拥有的一个对象，而您从不直接接触。
  2. 在这里，我使用的“对象”更像是非程序员——只是表示“某些东西”，不一定是类的实例。它甚至可能不是 C 使用这个词的意义上的“对象”——它可能是一个纯右值（例如，push_back(10)）。
于 2013-01-16T15:20:18.227 回答
2

是的。如果您存储对象而不是指向动态内存的指针，那么您不需要进行任何释放。
当你弹出元素时。标准库注意调用弹出对象的析构函数。

规则是：如果你分配了一些东西（调用
）， 你只需要释放（调用delete）。new

于 2013-01-16T15:17:02.140 回答
2

我的理解是，如果一个装满对象的容器超出范围，那么其中包含的所有对象也是如此。正确的？

首先，一些重要的迂腐。 对象不会超出范围，标识符会。这是一个重要的区别，它可能有助于澄清这里发生了什么：

当容器对应的标识符（变量）超出范围时，对应的对象（容器本身）会被自动删除。然后它的析构函数依次删除它的每个元素。

但是如果我们从容器中移除一个对象，std::list<T>.pop_front()例如使用呢？

容器只是删除包含的元素（就您而言，它调用它的析构函数）。（可能还有其他的内务处理，例如将所有剩余的元素在 a 中移动一个std::vector，这会导致大量的析构函数/复制构造函数调用）。

于 2013-01-16T15:17:09.367 回答
2

如果从 STL 容器中删除一个对象，如果它是一个结构/类类型，它的析构函数就会被调用。同样取决于容器，用于存储对象的内部数据结构也会被释放/销毁。

请记住，指针类型不是结构/类类型，因此没有可以管理指向的内存的析构函数。因此，如果您想在从 STL 容器中删除指针时避免意外的内存泄漏，最好使用智能指针类型，这样std::shared_ptr<T>可以正确管理分配给指针的内存，并在没有更多引用时释放它分配的内存对象。

于 2013-01-16T15:17:22.553 回答
2 
std::list<animal> alist;
// A list is created in automatic storage (the stack).  Its elements
// will exist in the free store (the heap)
{
  animal ani;
  // ani is created in automatic storage (the stack)

  alist.push_back(ani);
  // A copy of ani (using animal(const animal&) ctor) is created in
  // the list "alist" via memory allocated on the free store (the heap)

} // ani.~animal() is called, then the storage for ani is recycled
// (ie, the stack space that ani used can be reused)

{
  animal b = alist.front();
  // either animal(animal&) or animal(animal const&)
  // is called on the previous line, constructing an instance
  // of animal called "b" in automatic storage (the stack)
  // This is a copy of a copy of the animal instance called "ani"
  // above, assuming nothing else besides this code has manipulated
  // alist

  alist.pop_front();
  // The animal in the alist that is a copy of ani is destroyed
  // from the free store (the heap)


  //do stuff with b
} // b.~animal() is called, then the memory in automatic storage
// (the stack) that b lived in is recycled for other purposes
于 2013-01-16T15:22:13.867 回答