vector elements allocated on stack?

Question

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

The code above prints as expected:

0
1

But I have two questions:

1. is A{} created on the stack? Will it be cleaned after run() returns?
2. is a allocated on the stack? Will it be cleaned after append() returns?

Update:

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

Output:

+++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.

I updated the code in my question, adding the copy/move constructors. I found copy constructor was called 3 times in append. I understand auto a = v.back(); needs a copy, But the two other copies maybe should be avoided?

Answer 1

is a allocated on the stack?

There is no such thing as "stack" storage in the language. a has automatic storage.

As far as language implementations are concerned, this typically means that the variable is probably stored in a register, or on stack, or nowhere.

Will it be cleaned after append() returns?

Yes. Automatic variables are destroyed automatically when they go out of scope.

is A{} created on the stack?

A{} is a temporary object. The language is a bit vague about the storage class of temporary objects, but it is clear about the lifetime.

Will it be cleaned after run() returns?

In this case, the temporary object is destroyed at the end of the full expression, which is before run returns.

---

vector elements allocated on stack?

No. Vector elements are created in dynamic storage.

---

Update

But the two other copies maybe should be avoided?

If your endgoal is to get a vector with two elements, you can avoid all of the copies like this:

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

Answer 2

In this function

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

the variable a has the automatic storage duration and is a local variable of the function. It will not be alive after exiting the function.

In this function

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

again the variable v has the automatic storage duration and is a local variable of the function. When the function will finish its execution the variable will be destroyed. And all elements of the vector (that are placed in the heap) also will be destroyed due to the destructor of the vector.

Consider the following demonstrative program.

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

Its output might look like

&v = 0x7ffc27288dd0

&a = 0x7ffc27288dcc

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

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

As you can see the addresses of the vector v and the object a looks similarly because they are allocated in the same outer block scope of the function and have the automatic storage duration.

&v = 0x7ffc27288dd0
&a = 0x7ffc27288dcc

And they are not changed when new values are pushed on the vector.

However the addresses of the elements of the vector as for example

&v[0] = 0x55725232ee80

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

have a different representation and can be changed when a new elements are added to the vector because the memory for them can be dynamically reallocated.

EDIT: After you updated your question then take into account that when a new element is added to the vector the elements of the vector can be reallocated calling the copy constructor. You can use the method reserve to reserve enough memory to avoid its reallocation and the method emplace_back.

Answer 3

The C++ specification doesn't actually say.

With v.push_back(A{}) the A{} part creates a temporary object, which is then moved or copied into the vector, and then the temporary object is discarded.

Same with local variables, really, the "stack" is actually never mentioned by the C++ standard, it only tells how life-time should be handled. That a compiler might use a "stack" is an implementation detail.

With that said, most C++ compilers will use the "stack" to store local variables. Like for example the variable a in the append function. As for the temporary object created for v.push_back(A{}) you need to check the generated assembly code.

For the life-times, the life-time of the temporary object A{} ends as soon as the push_back function returns. And the life-time of a in the append function ends when the append function returns.