emplace_back没有创建就地对象

Question

    #include <iostream>
    #include<vector>
    using namespace std;

    class test{
        public:
        test(){
        cout<<"constructor called"<<endl;
    }
     test(const test& obj){
      cout<<"copy constructor called"<<endl;
     }
     test(test&& obj){
      cout<<"Move constructor called"<<endl;
    }     
    };
  int main()
  {
      vector<test> vec;
      vec.emplace_back(test());

      return 0;
  }

When i run above program I expected emplace_back to create object in vector in place.Thus "constructor called" should have been output since emplace_back would avoid creating temporary object.

But the output is:

constructor called
Move constructor called

Here, temporary object is created just like push_back. Please explain.

Answer 1

emplace_back doesn't construct temporaries, but you constructed a temporary object explicitly by test() , then the new element is added to the vector from the temporary by the move constructor.

You can just

vec.emplace_back();

Answer 2

With emplace_back(test()) you already created an object outside of emplace_back and it has a move constructor so it is move-constructed. So you should call it without any argument for this case. Then you will not see any copy/move constructor calls.

vec.emplace_back(); // Will create a test object with constructor `test()` internally

To further understand, if your test class have more constructors, you can give emplace_back with those constructors. For example,

class test {
  ...
  test(int a, int b);
  test(const char* c);
};

And you can do this.

vec.emplace_back(1, 2);
vec.emplace_back("abcd");

This does not create redundant object which is cannot be done with push_back .

Answer 3

With emplace_back , the method already knows what class type that you're adding to your vector (you name it when initialising the vector), so the input arguments for emplace_back is only the arguments for the constructor that you want to call (typically you want to avoid the copy constructor, whose argument is an object of the same class):

struct A
{
    A (int a, int b, int c)
    {
    // do something
    }

    A (const A & other)
    {
    //do something else
    }
};

std::vector<A> array;

array . emplace_back (1, 2, 3);
// the above finds the constructor with these input arguments
// makes the new object within the vector - no copy

A obj (4, 5, 6);

array . emplace_back ( obj );
// the above looks for the constructor with this object (A)
// it finds a constructor (the copy constructor) and copies

array . emplace_back ( A (1,2,3) );
// the above first processes the inner part: making a new A object
// then searches for a constructor with that argument (an object A)
// in this case that's the copy constructor

In your case you were wanting to call a constructor with no arguments. This is why you want to use emplace_back() with no arguments to use this vector method correctly.