向量元素分配在堆栈上？

如何解决向量元素分配在堆栈上？

#include <iostream>
#include <vector>

using namespace std;

struct A {
  int i = 0;
};

void append(vector<A>& v) {
  auto a = v.back(); // is a allocated on the stack? Will it be cleaned after append() returns?
  ++a.i;
  v.push_back(a);
}

void run() {
  vector<A> v{};
  v.push_back(A{}); // is A{} created on the stack? Will it be cleaned after run() returns?
  append(v);

  for (auto& a : v) {
    cout << a.i << endl;
  }
}

int main() {
  run();
  return 0;
}

上面的代码按预期打印：

0
1

但是我有两个问题：

是否在堆栈上创建了A {}？在run（）返回后会清除它吗？
是否在堆栈上分配了？会在append（）返回后将其清除吗？

更新：

#include <iostream>
#include <vector>

using namespace std;

struct A {
  int i = 0;

  A() { cout << "+++Constructor invoked." << endl; }

  A(const A& a) { cout << "Copy constructor invoked." << endl; }

  A& operator=(const A& a) {
    cout << "Copy assignment operator invoked." << endl;
    return *this;
  };

  A(A&& a) { cout << "Move constructor invoked." << endl; }

  A& operator=(A&& a) {
    cout << "Move assignment operator invoked." << endl;
    return *this;
  }

  ~A() { cout << "---Destructor invoked." << endl; }
};

void append(vector<A>& v) {
  cout << "before v.back()" << endl;
  auto a = v.back();
  ++a.i;
  cout << "before v.push_back()" << endl;
  v.push_back(a);
  cout << "after v.push_back()" << endl;
}

void run() {
  vector<A> v{};
  v.push_back(A{});
  cout << "entering append" << endl;
  append(v);
  cout << "exited append" << endl;

  for (auto& a : v) {
    cout << a.i << endl;
  }
}

int main() {
  run();
  return 0;
}

输出：

+++Constructor invoked.
Move constructor invoked.
---Destructor invoked.
entering append
before v.back()
Copy constructor invoked.
before v.push_back()
Copy constructor invoked.
Copy constructor invoked.
---Destructor invoked.
after v.push_back()
---Destructor invoked.
exited append
0
0 // I understand why it outputs 0 here. I omitted the actual work in my copy/move constructors overloads.
---Destructor invoked.
---Destructor invoked.

我更新了问题代码，添加了复制/移动构造函数。我发现复制构造函数在追加中被调用了3次。我了解自动a = v.back（）;需要一个副本，但是应该避免另外两个副本吗？

解决方法

C ++规范实际上并没有说。

通过v.push_back(A{})，A{}部分创建一个临时对象，然后将其移动或复制到向量中，然后丢弃该临时对象。

与局部变量相同，实际上，C ++标准实际上从未提到过“堆栈”，它仅说明应如何处理生命周期。编译器可能使用“堆栈”是实现的详细信息。

话虽如此，大多数C ++编译器都会使用“堆栈”来存储局部变量。例如，例如a函数中的变量append。至于为v.push_back(A{})创建的临时对象，您需要检查生成的汇编代码。

在生命周期中，A{}函数返回后，临时对象push_back的生命周期结束。当a函数返回时，append函数中append的生存期结束。

此功能

void append(vector<A>& v) {
  auto a = v.back(); // is a allocated on the stack? Will it be cleaned after append() returns?
  ++a.i;
  v.push_back(a);
}

变量a具有自动存储期限，并且是该函数的局部变量。退出该功能后将无法恢复运行。

此功能

void run() {
  vector<A> v{};
  v.push_back(A{}); // is A{} created on the stack? Will it be cleaned after run() returns?
  append(v);

  for (auto& a : v) {
    cout << a.i << endl;
  }
}

再次

变量v具有自动存储持续时间，并且是该函数的局部变量。函数完成执行后，变量将被销毁。而且向量的所有元素（放置在堆中）也将由于向量的析构函数而被破坏。

请考虑以下演示程序。

#include <iostream>
#include <vector>

struct A {
  int i = 0;
};

int main() 
{
    std::vector<A> v;
    
    std::cout << "&v = " << &v << "\n\n";
    
    A a;
    
    std::cout << "&a = " << &a << "\n\n";
    
    v.push_back( a );
    
    std::cout << "&v = " << &v << '\n';
    std::cout << "&a = " << &a << '\n';
    std::cout << "&v[0] = " << &v[0] << "\n\n";

    ++a.i;
    
    v.push_back( a );
    
    std::cout << "&v = " << &v << '\n';
    std::cout << "&a = " << &a << '\n';
    std::cout << "&v[0] = " << &v[0] << '\n';
    std::cout << "&v[1] = " << &v[1] << "\n\n";

    return 0;
}

其输出可能看起来像

&v = 0x7ffc27288dd0

&a = 0x7ffc27288dcc

&v = 0x7ffc27288dd0
&a = 0x7ffc27288dcc
&v[0] = 0x55725232ee80

&v = 0x7ffc27288dd0
&a = 0x7ffc27288dcc
&v[0] = 0x55725232eea0
&v[1] = 0x55725232eea4

如您所见，向量v和对象a的地址看起来相似，因为它们被分配在函数的相同外部块范围内，并且具有自动存储期限。

&v = 0x7ffc27288dd0
&a = 0x7ffc27288dcc

当在向量上施加新值时，它们不会更改。

但是矢量的元素地址例如

&v[0] = 0x55725232ee80

&v[0] = 0x55725232eea0
&v[1] = 0x55725232eea4

具有不同的表示形式，当向向量中添加新元素时可以更改，因为它们的内存可以动态重新分配。

编辑：更新问题后，请考虑到在将新元素添加到向量中时，可以调用复制构造函数来重新分配向量的元素。您可以使用方法reserve保留足够的内存来避免重新分配内存，而可以使用方法emplace_back。

是在堆栈上分配的吗？

语言中没有“堆栈”存储之类的东西。 a具有自动存储功能。

就语言实现而言，这通常意味着该变量可能存储在寄存器中，或在堆栈中，或在任何地方。

append（）返回后会清除吗？

是的。自动变量超出范围会自动销毁。

在堆栈上创建了A {}吗？

A{}是一个临时对象。该语言对临时对象的存储类有点含糊，但是对于生存期很清楚。

run（）返回后会清除吗？

在这种情况下，临时对象在完整表达式的结尾处（即run返回之前被销毁）。

在堆栈上分配的向量元素？

不。向量元素是在动态存储中创建的。

更新

但是应该避免另外两个副本吗？

如果最终目标是获得带有两个元素的向量，则可以避免所有这样的复制：

std::vector<A> v(2);

向量元素分配在堆栈上？

如何解决向量元素分配在堆栈上？

解决方法

相关推荐