emplace_back is not creating inplace object - c++

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.