C++矢量对象和过度调用析构函数？

Question

我想知道的是代码是否多次调用析构函数，以及它是否正确以这种方式编码。看起来像创建的对象在加载到矢量中之前超出了范围，但对象并未死亡，而是停留在向量中，并在程序完成时再次破坏。继承人的输出：

object::constructor: 
before push_back 
object::destructor: 
object::constructor: 
before push_back 
object::destructor: 
object::destructor: 
object::call(): begin 
0 
object::call(): end 
object::call(): begin 
1 
object::call(): end 
object::destructor: 
object::destructor: 

Process returned 0 (0x0) execution time : 0.313 s 
Press any key to continue. 

这是main.cpp中

#include <vector> 
#include <iostream> 
#include "object.h" 

int main() 
{ 
    int max = 2; 
    std::vector <object> OBJECTS; 

    for(int index = 0; index < max; index++) 
    { 
      object OBJECT(index); 
      std::cout<<"before push_back"<<std::endl; 
      OBJECTS.push_back(OBJECT); 
    } 

    for(int index = 0; index < max; index++) 
     OBJECTS[index].call(); 

    return 0; 
} 

，这是object.h

#ifndef OBJECT_H 
#define OBJECT_H 

#include <iostream> 

class object 
{ 
     private: 

      int value; 

     public: 

     object(){} 
     object(int value) 
     { 
      std::cout<<"object::constructor: "<<std::endl; 
      this->value = value; 
     } 
     ~object() 
     { 
      std::cout<<"object::destructor: "<<std::endl; 
     } 
     void call() 
     { 
      std::cout<<"object::call(): begin"<<std::endl; 
      std::cout<<value<<std::endl; 
      std::cout<<"object::call(): end"<<std::endl; 
     } 
}; 
#endif 

这是从回答Chowlett下面的代码，只需在案件的情况下。

#include <iostream> 
#include <vector> 

class object 
{ 
     private: 

      int value; 

     public: 

     object(){} 
     object(int value) 
     { 
      std::cout<<"object::constructor: "<< value << std::endl; 
      this->value = value; 
     } 
     object(const object& o) 
     { 
      std::cout<<"object::copy-constructor: " << o.value << std::endl; 
      this->value = o.value + 10; 
     } 
     ~object() 
     { 
      std::cout<<"object::destructor: "<< value << std::endl; 
     } 
     void call() 
     { 
      std::cout<<"object::call(): begin"<<std::endl; 
      std::cout<<value<<std::endl; 
      std::cout<<"object::call(): end"<<std::endl; 
     } 
}; 

int main() 
{ 
    int max = 3; 
    std::vector <object> OBJECTS; 

    for(int index = 0; index < max; index++) 
    { 
      object OBJECT(index); 

      std::cout<<"before push_back: capacity="<< OBJECTS.capacity() << std::endl;    
      OBJECTS.push_back(OBJECT); 
      std::cout<<"after push_back: capacity="<< OBJECTS.capacity() << std::endl; 
    } 

    for(int index = 0; index < max; index++) 
     OBJECTS[index].call(); 

    return 0; 
} 

Answer 1

发生了什么事是，vector被重新分配，以腾出空间。

OBJECTS从capacity开始等于零。循环构造OBJECT = object(0)，然后复制构建该对象的副本以传递至push_back。 push _back笔记没有足够的空间（1> 0！），因此它重新分配vector以具有1的容量并放入副本。然后破坏OBJECT。

下一次通过循环，OBJECT = object(1)被构建，然后复制构造为push_back。再次没有足够的空间，所以OBJECTS被重新分配以具有更大容量 - 并且已经在其中的对象（0）被复制构建到重新分配的空间中，并且原始的被破坏的。然后复制对象被放入，并且OBJECT被再次破坏。

This代码中的变体应该说明发生了什么。我已经让代码在每个push_back之前和之后编写了vector;并且我添加了日志复制构造器。每次它被调用时，我还使复制构造函数添加10到value，这样您就可以看到每个单独的object是如何被复制的。

Answer 2

编译器为您生成了copy-ctor。添加一个与一些调试输出，你可以了解你的代码是这样做的：

object(const object& o) 
{ 
    std::cout<<"object::copy-constructor: "<<std::endl; 
    this->value = o.value; 
}