c++ vector对象和对析构函数的过多调用

C++ vector of objects and excessive calls to destructor?

本文关键字：调用 析构函数 vector 对象 c++      更新时间：2023-10-16

我想知道的是代码是否多次调用析构函数，以及以这种方式编写代码是否正确。似乎创建的对象在被加载到vector中之前就超出了作用域，但对象并没有死亡，而是留在vector中，并在程序完成后再次销毁。下面是输出:

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.


#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;
}

这是对象。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;
}

编译器为您生成了一个复制器。添加一个带有调试输出的文件，您就可以理解代码在做什么了:

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

vector正在重新分配以腾出空间。

OBJECTS开始时capacity等于0。循环构造OBJECT = object(0)，然后复制构造该对象的副本以传递给push_back。push _back注意到没有足够的空间(1> 0!)，所以它重新分配vector的容量为1，并将副本放进去。然后破坏OBJECT。

下一次循环时，先构造OBJECT = object(1)，然后为push_back构造copy-construct。又没有足够的空间了，所以重新分配OBJECTS以获得更大的容量——，并且已经在其中的对象(0)被复制构造到重新分配的空间中，并且原始的销毁。然后将复制的对象放入，并再次解构OBJECT。

你的代码的这种变化应该清楚地表明发生了什么。我已经让代码在每个push_back之前和之后编写vector容量;我还添加了一个日志复制构造器。我还让复制构造器在每次调用value时为其添加10，这样您就可以看到每个object是如何被复制的。

相关文章：