Question

我使用的是borland 2006 c ++

class A
{
private:
    TObjectList* list;
    int myid;
public:
 __fastcall A(int);
 __fastcall ~A();
};

__fastcall A::A(int num)
{
    myid = num;
   list = new TObjectList();
}

__fastcall A::~A()
{
}

int main(int argc, char* argv[])
{
  myfunc();
  return 0;
}

void myfunc()
{
    vector<A> vec;
    vec.push_back(A(1));
}

当我向向量添加一个新对象A时，它会调用它的析构函数两次，然后当vec超出范围时调用一次，所以总共调用3次。

我认为它应该在添加对象时调用一次，然后在vec超出范围时调用一次。

Answer 1

表达式A(1)是一个r值并构造一个新的A值，然后编译器可以将其复制到一个临时对象中，以便绑定到push_back的const引用需要。然后将引用绑定的临时值复制到vector管理的存储中。

在许多情况下，允许编译器忽略临时对象，但不需要这样做。

Answer 2

试试这个：

#include <iostream>
#include <vector>

class A
{
    private:
        public:
            A(int num)
            {
                std::cout << "Constructor(" << num << ")\n";
            }
            A(A const& copy)
            {
                std::cout << "Copy()\n";
            }
            A& operator=(A const& copy)
            {
                std::cout << "Assignment\n";
                return *this;
            }
            A::~A()
            {
                std::cout << "Destroyed\n";
            }
};

int main(int argc, char* argv[])
{
    std::vector<A> vec;
    vec.push_back(A(1));
}

我机器上的输出是：

> ./a.exe
Constructor(1)
Copy()
Destroyed
Destroyed
>

Answer 3

当您点击断点时，单击调试器底部的调用堆栈选项卡。这样，您就可以找到每个调用的上下文。

stl向量添加序列

3 个答案: