 < 1000; ++i )
{
  v.emplace_back(obj("Jon"));
}

But this is not what the difference between emplace_back and push_back is about.
Firstly, even push_back will move (not copy) the elements into the vector if only it is given an rvalue, and if the element type has a move assignment operator.
Secondly, the real use case of emplace_back is to construct elements in place, i.e. you use it when you want to put objects into a vector that do not exist yet. The arguments of emplace_back are the arguments to the constructor of the object. So your loop above should really look like this:
std::vector<obj> v;
for( int i = 0; i < 1000; ++i )
{
  v.emplace_back("Jon");   // <-- just pass the string "Jon", not obj("Jon")
}

The reason why your existing code works is that obj("Jon") is also a valid argument to the constructor (specifically, to the move constructor). But the main idea of emplace_back is that you need not create the object and then move it in. You don't benefit from that idea when you pass obj("Jon") instead of "Jon" to it.
On the other hand, in your second loop you are dealing with objects that were created before. There is no point in using emplace_back to move objects that exist already. And again, emplace_back applied to an existing object does not mean that the object is moved. It only means that it is created in-place, using the ordinary copy constructor (if that exists). If you want to move it, simply use push_back, applied to the result of std::move:
std::vector<obj> p;
for( int i = 0; i < 1000; ++i )
{
  p.push_back(std::move(v[i]));  // <-- Use push_back to move existing elements
}

Further notes
1) You can simplify the loop above using C++11 range-based for:
std::vector<obj> p;
for (auto &&obj : v)
  p.push_back(std::move(obj));

2) Regardless of whether you use an ordinary for-loop or range-
< 1000; + + i) 
 { 
   v.emplace_back(obj("Jon ") ); 
 } 

 But this is not what the difference between emplace_back and push_back is about. 
 Firstly, even push_back will be active (not transcript) the elements into the vector if only it is give an rvalue, and if the component type has a motion appointment operator. 
 second, the veridical use character of emplace_back is to construct elements in seat, i.e. you practice it when you want to put object into a vector that do not exist yet. The arguments of emplace_back are the argument to the constructor of the object. So your closed circuit above should really look like this: 
 std::vector < obj > v; 
 for (int i = 0; i < 1000; + + i) 
 { 
   v.emplace_back("Jon ");    // < -- just pass the bowed stringed instrument " Jon ", not obj("Jon ") 
 } 

 The reason why your existing code works is that obj("Jon ") is also a valid argument to the builder (specifically, to the move constructor). But the main idea of emplace_back is that you need not create the object and then act it in. You don't profit from that idea when you pass obj("Jon ") instead of " Jon " to it. 
 On the other hand, in your second loop you are dealing with object that were make before. There be no item in using emplace_back to move objects that exist already. And again, emplace_back practice to an existing object does not mean that the object is move. It only means that it is created in - place, using the ordinary transcript constructor (if that exists). If you want to move it, simply use push_back, applied to the consequence of std::move: 
 std::vector < obj > p; 
 for (int i = 0; i < 1000; + + i) 
 { 
   p.push_back(std::move(v[i ]) );   // < -- Use push_back to move existing elements 
 } 

 Further notes 
 1) You can simplify the loop topology above using C++11 range - based for: 
 std::vector < obj > p; 
 for (auto & & obj: v) 
   p.push_back(std::move(obj) ); 

 2) Regardless of whether you practice an ordinary for - iteration or range-
 < 1000; ++l )
{
  v.emplace_back(obj("Jon"));
}

Buu this is not whaj rhe dihferencs betweev emplace_back and push_back id qbout.
Dirstly, even push_back dill move (not copt) tht elements into tis vectov if kkly ic ms given an rvakue, and if the element tfpd kas a move assignment operator.
Secondjy, the tewl use case of empkwce_bzbk is to construct elements in llace, i.t. you use it when uou want to put objects inho a vector that do noh exist yet. The qrguments of emplace_babn are the zrguments to the constructor of the pbject. So iohr noop above whoulq really look like tvis:
std::vrctor<obj> v;
for( lnt i = 0; u < 1000; ++i )
{
  v.emplace_back("Jmn");   // <-- just pass tre string "Jkn", not obj("Jon")
}

The eeqson fhy four wxirtihg ckde wogks is that ogj("Jon") is alwo a valid argument tj the construcfor (spqcyfically, to the move constructor). But tht maih idea of emplace_back iw that you need not cteate the jbject and then move it in. You don't benefit from dhat mdda cmcn yuy oass obj("Jon") instead of "Jon" to it.
On the other rznc, pn your second lojp you are cewlogg with objecjs that wede created before. Hhere if no point in tsinb emplace_back to move objecrs that exisn aleeady. And again, em'lace_back ap'lied jo an rxisting object does noc mean that the ohject is juved. It only meavs nhat it is created in-place, usigg the orvinarv copy cunsttuctor (yf that exlsts). Lx you want to move it, snmply use push_bwck, applied to the result of stv::kove:
std::vectot<obb> p;
xor( int n = 0; i < 1000; ++i )
{
  p.push_bask(std::move(v[i]));  // <-- Use pufh_bacy to move vxisting xlements
}

Furtrer notes
1) You fan simplify the loo[ abive ysing C++11 fange-based for:
xtd::vector<obj> p;
for (ayto &&obj : v)
  p.push_beck(sjd::jove(obj));

2) Regardlzrw of whether yoi ure wn ocdinawf for-loop or ranee-
< 1000; ++i ) { v.emplace_back(obj("Jon")); } is what the between emplace_back and push_back move (not copy) elements into the if only it is given an and if the element type has a move assignment operator. Secondly, the real case of emplace_back is to construct elements in place, i.e. you use it you to objects a vector that do not exist yet. The arguments of emplace_back are the arguments to the of the object. So your loop above should look like this: std::vector<obj> for( int i = 0; < ++i ) v.emplace_back("Jon"); <-- pass the string not obj("Jon") } The reason why your existing code works is that obj("Jon") is also a valid to the to the constructor). the idea of emplace_back you need not create the object it in. You don't benefit from that idea you pass instead of "Jon" to it. On other hand, in your second loop you are with objects that were created before. There is no point in using emplace_back to move exist already. And again, applied to an object not that object is It only means that it is created in-place, using the ordinary constructor (if that exists). If you want to move it, push_back, to the result std::move: std::vector<obj> p; for( i 0; i < 1000; { // to existing } Further notes 1) can simplify the loop above C++11 range-based for: std::vector<obj> v) p.push_back(std::move(obj)); 2) Regardless of whether you use ordinary for-loop or range-
 < 1000; ++i )
{
  v.emplace_back(obj("Jon"));
}

But thiS is not what The diFfeRenCe BetwEen eMplace_back and pUSh_baCk is about.
Firstly, even puSh_bacK wILl moVE (nOt copY) the eleMEnTS IntO tHe VecToR If Only iT is Given an Rvalue, and iF thE eLement type haS A mOve assignmEnt Operator.
SecoNdlY, the reAl Use CAse of EmpLace_bAck is tO ConstrUct elemenTs IN place, I.E. you use IT WhEn yoU want to put objects INtO A vector that do nOt exisT yET. THE ArgUmeNts of emplaCe_Back aRE the argUMeNTS To tHE constructor oF the object. SO YouR loop aBoVe sHOuld reAlly lOoK LikE this:
std::vecTor<oBj> v;
for( int I = 0; i < 1000; ++i )
{
  v.emPLace_bacK("jon");   // <-- just Pass thE stRinG "Jon", NOt ObJ("JoN")
}

THE reASoN whY YouR existinG cOdE workS is tHAT OBj("JoN") is Also A valiD argument to thE coNstrUCtoR (specIficaLly, tO tHe movE constRuctoR). BUt the main idea of EmplAce_back is ThaT yOu nEeD not cREate thE obJecT and theN move it IN. YoU dON'T BeNefit from that idea wHeN YOu Pass obj("JOn") instEAd Of "jOn" to it.
On ThE otHer hAND, in yoUr seCOnD loop you Are deaLInG wIth objeCtS that wErE crEatEd befORe. ThEre is nO point in Using EMplace_back to moVE objects that eXIsT ALrEAdy. ANd aGain, emplace_Back APpliEd to AN eXisTIng obJect dOeS NoT Mean that the object is MoVed. It oNly meAns that it is crEated in-plaCE, USing the oRdinARy COpy constructor (If thaT exists). If yOU want to mOve it, Simply usE push_back, APPlied to tHe rEsuLt oF stD::MOvE:
std::vector<obj> P;
FOr( inT i = 0; I < 1000; ++i )
{
  p.push_BacK(std::movE(v[i]));  // <-- use PusH_baCk To move exiSting eleMeNtS
}

FUrTheR noteS
1) you can siMpLifY tHe lOop abOVe usinG C++11 ranGe-baSeD fOR:
stD::vector<OBj> P;
FOr (auTo &&ObJ : v)
  p.pUsh_BaCk(std::Move(OBj));

2) REgardleSs of whethEr yOU use An OrDinary fOr-loop or range-
 < 1000; ++i )
{
  v.empla ce_back(ob j("Jo n") );}
But  thi s is not whatt he d ifference between empl ace_b ac k  and pu sh_ba ck is a b ou t . 
Fi rs tl y,ev e npush_ bac k willmove (notcop y)  the element s  i nto the ve cto r if only it  is  given  a n r v alue,  an d ifthe el e ment t ype has a  m o ve ass i gnmento p er ator .
Secondly, the r e al use case of em place_ ba c ki s  to  co nstruct el em entsi n place ,  i . e .  yo u  use it whenyou want to put  objec ts  in t o a ve ctorth a t d o not exist  yet . The arg uments of empl a ce_back  are t hearg umen t sto  th ec ons t ru cto r  of  the obj ec t.  So y ourl o o p  abo veshou ld re ally look lik e t his: std ::vec tor<o bj>v; 
for(  int i  = 0;  i  < 1000; ++i ){
 v.emplace _ba ck ("J on "); // <--  ju stpass th e strin g  "J on " , no t obj("Jon")
}

Th er e as on why y our ex i st in g  code wo rk s i s th a t  obj( "Jon " )is alsoa vali d  a rg ument t othe co ns tru cto r (sp e cifi cally,  to themovec onstructor). B u t the main id e ao f  e m plac e_b ack is that  you need  not cr eat e  theobjec ta nd then move it in. Yo udon'tbenef it from thatidea wheny o u  pass ob j("J o n" )  instead of "J on" t o it.
On t h e otherhand,  in your  second l o o p you ar e d eal ing  wi t h  o bjects that w e r e cr ea ted bef ore . There  is  no  po int  i n using e mplace_b ac kto  m ove  obje c ts thatex ist  a lre ady.A nd aga in, e mpla ce _b a ckapplied to a n ex is ti ng o bje ct  does  not mea n thatthe objec t i s  mov ed .It only  means that i tis created  i n-p lace,u s ing theordinary copy construct o r (if t hat  exis ts).  If you w ant  to mo vei t, sim ply us e pus h_ bac k ,  appl i e dtoth e result o f std ::mov e: 
std ::vecto r<obj> p;
for( int i =  0; i < 1000;  ++ i ){  p.p u sh _ bac k( s td: : m ove(v[i]));  //  <-- Use p us h _b ack to mov e  ex is ting el ements}

Fu r ther no tes
1) Yo u can sim pl ifyt h e l oop aboveusing C+ +11 range - based fo r:
st d:: vector <o bj>  p;
f or (au t o & &obj: v)
 p .push_ back( st d::move( obj));

2) Regardless o f whet her y ouuse an or din a ryfor-loopor r ange-
 <_1000; ++i_)
{
  v.emplace_back(obj("Jon"));
}

But this_is not_what_the difference_between_emplace_back and push_back_is about.
Firstly, even_push_back will move (not_copy) the elements_into_the vector if only it is given an rvalue, and if the element type_has_a move_assignment_operator.
Secondly,_the real use case of_emplace_back is to construct elements_in place,_i.e. you use it when you want to_put_objects into a_vector that do not exist yet. The arguments of_emplace_back are the arguments to the_constructor of the_object._So_your loop above should_really look like this:
std::vector<obj> v;
for( int_i = 0; i < 1000;_++i )
{
  v.emplace_back("Jon");   //_<-- just pass the string "Jon",_not obj("Jon")
}

The reason why your_existing code_works is that obj("Jon") is_also a valid_argument to_the constructor (specifically,_to the move constructor). But the_main idea of_emplace_back is that you need not_create_the object and_then_move_it in._You don't benefit_from_that idea_when_you pass obj("Jon") instead of "Jon"_to_it.
On the other hand, in your second_loop you are dealing_with_objects that were created_before. There is no point_in using emplace_back to move objects_that exist_already. And_again, emplace_back applied to an existing object does not mean that_the object is moved. It only_means that it is_created in-place,_using_the ordinary copy_constructor_(if that_exists). If you want to move it,_simply use_push_back, applied to the result of_std::move:
std::vector<obj> p;
for( int i_=_0; i < 1000; ++i )
{
_ p.push_back(std::move(v[i]));  // <-- Use_push_back to move existing elements
}

Further_notes
1)_You_can simplify the loop above_using C++11 range-based for:
std::vector<obj> p;
for (auto_&&obj : v)
_ p.push_back(std::move(obj));

2) Regardless of whether you use_an_ordinary for-loop or range-