Suppose I have the following:

class Test {};

Test a;

vector<Test> v;

v.push_back(std::move(a));

Basically,now a has been moved to the vector(so it is a part of the vector now),but,what happens if I try to access the original a?(not the one that is in the vector now?)

That depends on the implementation of the move constructor and the data you're trying to access. The variable a has not been 'moved', it still resides in the same memory location occupying the same space. The variable that's been constructed in the vector can steal contents from a. If for example a holds a pointer to an array, this pointer could be copied and then set to null for a, accessing the pointer through a would then result in a nullpointer error.

After std::move, 'a' is left in a valid but unspecified state. (http://en.cppreference.com/w/cpp/utility/move)

Correct me if I'm wrong, but there's little point in calling std::move on an lvalue (as is the case in your code).

It'd make more sense like this:

vector<Test> v;
v.push_back(std::move(Test()));

Correct me if I'm wrong, but there's little point in calling std::move on an lvalue (as is the case in your code).

It'd make more sense like this:

vector<Test> v;
v.push_back(std::move(Test()));

You are wrong. In your example you don't even need the std::move because 'Test()' is an xvalue as an expiring temporary. The whole point of std::move it to allow it on what would usually be lvalues.

Also, if the intention is to construct a temporary object just to pass it to push_back, you should instead use emplace_back to construct it in-place inside the vector and skip the temporary object entirely.

Suppose I have the following:

class Test {};

Test a;
vector<Test> v;
v.push_back(std::move(a));

Basically,now a has been moved to the vector(so it is a part of the vector now),but,what happens if I try to access the original a?(not the one that is in the vector now?)

Since Test does not implement an explicit move constructor, it's just copy constructed. And since Test has no members, that's a no-op.

Since Test does not implement an explicit move constructor, it's just copy constructed. And since Test has no members, that's a no-op.

Setting aside the empty-class test case problem, according to this page the compiler should implicitly generate a move constructor. So in my understanding, if the test class contained expensive to copy members (like complex std::containers) the compiler would have generated a move constructor which could have been used.

I'm happy to be corrected though.