using namespace std;
#include <list>
#include <algorithm>
#include <iostream>
#include <string>
#include <sstream>
#include <utility>

class noCopyable
{
	string value;
public:
//	noCopyable(const noCopyable&) = delete; // Part1 works with this
	noCopyable(const noCopyable &b)
		{ 
			value = b.value;
			cout << "Called noCopyable copiin" << endl; 
		};  // shows calls, needed for copy list

	noCopyable(noCopyable&& b) : value(std::move(b.value)) 
	{ cout << "Moved noCopyable.. " << endl; }  // move constructor

//	noCopyable& operator = (const noCopyable&) = delete; // // Part1 works with this
	noCopyable& operator = (const noCopyable &b) 
	{ 
		value = b.value; 
		cout << "Called noCopyable assign" << endl; 
	} // needed for copinn list contens


	noCopyable(int x) { stringstream out; out << x; value = out.str(); }
	
	string getS() const {return value; }
	string& setS(string s) {return value = s; }

};

class Usual
{
	string value;
public:
	Usual(int x) { stringstream out; out << x; value = out.str(); }

	string getS() const {return value; }
};

int main()
{
	// Part1. create, iterate, modify
	// this works fine
	list<Usual> usuals;
	typedef list<Usual>::const_reference Uiter;
	usuals.push_front(1);
	usuals.push_front(2);
	usuals.push_front(3);

	for_each(usuals.begin(), usuals.end(), [](Uiter i){cout << i.getS() << ", "; } );
	cout << endl;
		
	// non copiable object wont work
    noCopyable canCreate(7); // <--- OK

	list<noCopyable> nocopies;
	typedef list<noCopyable>::reference Niter;

// no one push below works without copy __or move__ constructor
	nocopies.push_front(std::move(canCreate));
	nocopies.push_front(8);
	nocopies.push_front(9);
	cout << "nocopies formed." << endl;

	// print list
	for_each(nocopies.begin(), nocopies.end(), [](Niter i){cout << i.getS() << ", "; } );
	cout << endl;

	// modify list
	for_each(nocopies.begin(), nocopies.end(), [](Niter i){ i.setS(i.getS() + "+1"); } );

	// print list
	for_each(nocopies.begin(), nocopies.end(), [](Niter i){cout << i.getS() << ", ";});
	cout << endl;

	// Part2. Copy list. need copy constructor && assignment op
	list<noCopyable> nc2;
	nc2.assign(nocopies.begin(), nocopies.end());
	// print list1
	for_each(nocopies.begin(), nocopies.end(), [](Niter i){cout << i.getS() << ", ";});
	cout << endl;
	// print list2
	for_each(nc2.begin(), nc2.end(), [](Niter i){cout << i.getS() << ", ";});
	cout << endl;
		
	return 0;
}

>gcc -std=c++11 nocopySTL.cpp -lstdc++
>a.exe
3, 2, 1,
Moved noCopyable..
Moved noCopyable..
Moved noCopyable..
nocopies formed.
9, 8, 7,
9+1, 8+1, 7+1,
Called noCopyable copiin
Called noCopyable copiin
Called noCopyable copiin
9+1, 8+1, 7+1,
9+1, 8+1, 7+1,

#include <utility>
#include <string>
using namespace std;

class A {
	string member;
public:
	A(): member("Dory"){};
	A(A&& arg); 	// Simple move assignment operator
	A(A& arg); 	// copy
	A& operator=(A&& other);
};

A::A(A&& arg): member(std::move(arg.member)) // the expression "arg.member" is lvalue
{} 

A::A(A& arg): member(arg.member) // cpy
{} 

A& A::operator=(A&& other) 
{
   	member = std::move(other.member);
   	return *this;
}

void fingingDory()
{
	A dory; 
	A copydory(dory);
}

std_move.o:     file format pe-i386


Disassembly of section .text:

00000000 <__ZN1AC1EOS_>:
	A(A&& arg); 	// Simple move assignment operator
	A(A& arg); 	// copy
	A& operator=(A&& other);
};

A::A(A&& arg): member(std::move(arg.member)) // the expression "arg.member" is lvalue
   0:	55                   	push   ebp
   1:	89 e5                	mov    ebp,esp
   3:	83 ec 28             	sub    esp,0x28
   6:	89 4d f4             	mov    DWORD PTR [ebp-0xc],ecx
   9:	8b 45 08             	mov    eax,DWORD PTR [ebp+0x8]
   c:	89 04 24             	mov    DWORD PTR [esp],eax
   f:	e8 00 00 00 00       	call   14 <__ZN1AC1EOS_+0x14>
  14:	89 c2                	mov    edx,eax
  16:	8b 45 f4             	mov    eax,DWORD PTR [ebp-0xc]
  19:	89 14 24             	mov    DWORD PTR [esp],edx
  1c:	89 c1                	mov    ecx,eax
  1e:	e8 00 00 00 00       	call   23 <__ZN1AC1EOS_+0x23>
  23:	83 ec 04             	sub    esp,0x4
{} 
  26:	c9                   	leave  
  27:	c2 04 00             	ret    0x4

0000002a <__ZN1AC1ERS_>:

A::A(A& arg): member(arg.member) // cpy
  2a:	55                   	push   ebp
  2b:	89 e5                	mov    ebp,esp
  2d:	83 ec 28             	sub    esp,0x28
  30:	89 4d f4             	mov    DWORD PTR [ebp-0xc],ecx
  33:	8b 55 08             	mov    edx,DWORD PTR [ebp+0x8]
  36:	8b 45 f4             	mov    eax,DWORD PTR [ebp-0xc]
  39:	89 14 24             	mov    DWORD PTR [esp],edx
  3c:	89 c1                	mov    ecx,eax
  3e:	e8 00 00 00 00       	call   43 <__ZN1AC1ERS_+0x19>
  43:	83 ec 04             	sub    esp,0x4
{} 
  46:	c9                   	leave  
  47:	c2 04 00             	ret    0x4

0000004a <__ZN1AaSEOS_>:

A& A::operator=(A&& other) 
{
  4a:	55                   	push   ebp
  4b:	89 e5                	mov    ebp,esp
  4d:	83 ec 28             	sub    esp,0x28
  50:	89 4d f4             	mov    DWORD PTR [ebp-0xc],ecx
   	member = std::move(other.member);
  53:	8b 45 08             	mov    eax,DWORD PTR [ebp+0x8]
  56:	89 04 24             	mov    DWORD PTR [esp],eax
  59:	e8 00 00 00 00       	call   5e <__ZN1AaSEOS_+0x14>
  5e:	89 c2                	mov    edx,eax
  60:	8b 45 f4             	mov    eax,DWORD PTR [ebp-0xc]
  63:	89 14 24             	mov    DWORD PTR [esp],edx
  66:	89 c1                	mov    ecx,eax
  68:	e8 00 00 00 00       	call   6d <__ZN1AaSEOS_+0x23>
  6d:	83 ec 04             	sub    esp,0x4
   	return *this;
  70:	8b 45 f4             	mov    eax,DWORD PTR [ebp-0xc]
}
  73:	c9                   	leave  
  74:	c2 04 00             	ret    0x4

00000077 <__Z11fingingDoryv>:

void fingingDory()
{
  77:	55                   	push   ebp
  78:	89 e5                	mov    ebp,esp
  7a:	57                   	push   edi
  7b:	56                   	push   esi
  7c:	53                   	push   ebx
  7d:	83 ec 6c             	sub    esp,0x6c
  80:	c7 45 bc 00 00 00 00 	mov    DWORD PTR [ebp-0x44],0x0
  87:	c7 45 c0 06 00 00 00 	mov    DWORD PTR [ebp-0x40],0x6
  8e:	8d 45 c4             	lea    eax,[ebp-0x3c]
  91:	8d 5d e8             	lea    ebx,[ebp-0x18]
  94:	89 18                	mov    DWORD PTR [eax],ebx
  96:	ba ed 00 00 00       	mov    edx,0xed
  9b:	89 50 04             	mov    DWORD PTR [eax+0x4],edx
  9e:	89 60 08             	mov    DWORD PTR [eax+0x8],esp
  a1:	8d 45 a4             	lea    eax,[ebp-0x5c]
  a4:	89 04 24             	mov    DWORD PTR [esp],eax
  a7:	e8 00 00 00 00       	call   ac <__Z11fingingDoryv+0x35>
	A dory; 
  ac:	8d 45 e4             	lea    eax,[ebp-0x1c]
  af:	c7 45 a8 ff ff ff ff 	mov    DWORD PTR [ebp-0x58],0xffffffff
  b6:	89 c1                	mov    ecx,eax
  b8:	e8 00 00 00 00       	call   bd <__Z11fingingDoryv+0x46>
	A copydory(dory);
  bd:	8d 45 e0             	lea    eax,[ebp-0x20]
  c0:	8d 55 e4             	lea    edx,[ebp-0x1c]
  c3:	89 14 24             	mov    DWORD PTR [esp],edx
  c6:	c7 45 a8 01 00 00 00 	mov    DWORD PTR [ebp-0x58],0x1
  cd:	89 c1                	mov    ecx,eax
  cf:	e8 56 ff ff ff       	call   2a <__ZN1AC1ERS_>
  d4:	83 ec 04             	sub    esp,0x4
  d7:	8d 45 e0             	lea    eax,[ebp-0x20]
  da:	89 c1                	mov    ecx,eax
  dc:	e8 00 00 00 00       	call   e1 <__Z11fingingDoryv+0x6a>
  e1:	8d 45 e4             	lea    eax,[ebp-0x1c]
  e4:	89 c1                	mov    ecx,eax
  e6:	e8 00 00 00 00       	call   eb <__Z11fingingDoryv+0x74>
  eb:	eb 25                	jmp    112 <__Z11fingingDoryv+0x9b>
  ed:	8d 6d 18             	lea    ebp,[ebp+0x18]
  f0:	8b 45 ac             	mov    eax,DWORD PTR [ebp-0x54]
  f3:	89 45 a0             	mov    DWORD PTR [ebp-0x60],eax
  f6:	8d 45 e4             	lea    eax,[ebp-0x1c]
  f9:	89 c1                	mov    ecx,eax
  fb:	e8 00 00 00 00       	call   100 <__Z11fingingDoryv+0x89>
 100:	8b 45 a0             	mov    eax,DWORD PTR [ebp-0x60]
 103:	89 04 24             	mov    DWORD PTR [esp],eax
 106:	c7 45 a8 ff ff ff ff 	mov    DWORD PTR [ebp-0x58],0xffffffff
 10d:	e8 00 00 00 00       	call   112 <__Z11fingingDoryv+0x9b>
 112:	8d 45 a4             	lea    eax,[ebp-0x5c]
 115:	89 04 24             	mov    DWORD PTR [esp],eax
 118:	e8 00 00 00 00       	call   11d <__Z11fingingDoryv+0xa6>
 11d:	8d 65 f4             	lea    esp,[ebp-0xc]
 120:	5b                   	pop    ebx
 121:	5e                   	pop    esi
 122:	5f                   	pop    edi
 123:	5d                   	pop    ebp
 124:	c3                   	ret    
 125:	90                   	nop
 126:	90                   	nop
 127:	90                   	nop

Disassembly of section .text$_ZN1AC1Ev:

00000000 <__ZN1AC1Ev>:
using namespace std;

class A {
	string member;
public:
	A(): member("Dory"){};
   0:	55                   	push   ebp
   1:	89 e5                	mov    ebp,esp
   3:	57                   	push   edi
   4:	56                   	push   esi
   5:	53                   	push   ebx
   6:	83 ec 6c             	sub    esp,0x6c
   9:	89 4d d4             	mov    DWORD PTR [ebp-0x2c],ecx
   c:	c7 45 b8 00 00 00 00 	mov    DWORD PTR [ebp-0x48],0x0
  13:	c7 45 bc 00 00 00 00 	mov    DWORD PTR [ebp-0x44],0x0
  1a:	8d 45 c0             	lea    eax,[ebp-0x40]
  1d:	8d 5d e8             	lea    ebx,[ebp-0x18]
  20:	89 18                	mov    DWORD PTR [eax],ebx
  22:	ba 70 00 00 00       	mov    edx,0x70
  27:	89 50 04             	mov    DWORD PTR [eax+0x4],edx
  2a:	89 60 08             	mov    DWORD PTR [eax+0x8],esp
  2d:	8d 45 a0             	lea    eax,[ebp-0x60]
  30:	89 04 24             	mov    DWORD PTR [esp],eax
  33:	e8 00 00 00 00       	call   38 <__ZN1AC1Ev+0x38>
  38:	8d 45 e7             	lea    eax,[ebp-0x19]
  3b:	89 c1                	mov    ecx,eax
  3d:	e8 00 00 00 00       	call   42 <__ZN1AC1Ev+0x42>
  42:	8b 45 d4             	mov    eax,DWORD PTR [ebp-0x2c]
  45:	8d 55 e7             	lea    edx,[ebp-0x19]
  48:	89 54 24 04          	mov    DWORD PTR [esp+0x4],edx
  4c:	c7 04 24 01 00 00 00 	mov    DWORD PTR [esp],0x1
  53:	c7 45 a4 01 00 00 00 	mov    DWORD PTR [ebp-0x5c],0x1
  5a:	89 c1                	mov    ecx,eax
  5c:	e8 00 00 00 00       	call   61 <__ZN1AC1Ev+0x61>
  61:	83 ec 08             	sub    esp,0x8
  64:	8d 45 e7             	lea    eax,[ebp-0x19]
  67:	89 c1                	mov    ecx,eax
  69:	e8 00 00 00 00       	call   6e <__ZN1AC1Ev+0x6e>
  6e:	eb 25                	jmp    95 <__ZN1AC1Ev+0x95>
  70:	8d 6d 18             	lea    ebp,[ebp+0x18]
  73:	8b 45 a8             	mov    eax,DWORD PTR [ebp-0x58]
  76:	89 45 9c             	mov    DWORD PTR [ebp-0x64],eax
  79:	8d 45 e7             	lea    eax,[ebp-0x19]
  7c:	89 c1                	mov    ecx,eax
  7e:	e8 00 00 00 00       	call   83 <__ZN1AC1Ev+0x83>
  83:	8b 45 9c             	mov    eax,DWORD PTR [ebp-0x64]
  86:	89 04 24             	mov    DWORD PTR [esp],eax
  89:	c7 45 a4 ff ff ff ff 	mov    DWORD PTR [ebp-0x5c],0xffffffff
  90:	e8 00 00 00 00       	call   95 <__ZN1AC1Ev+0x95>
  95:	8d 45 a0             	lea    eax,[ebp-0x60]
  98:	89 04 24             	mov    DWORD PTR [esp],eax
  9b:	e8 00 00 00 00       	call   a0 <__ZN1AC1Ev+0xa0>
  a0:	8d 65 f4             	lea    esp,[ebp-0xc]
  a3:	5b                   	pop    ebx
  a4:	5e                   	pop    esi
  a5:	5f                   	pop    edi
  a6:	5d                   	pop    ebp
  a7:	c3                   	ret    

Disassembly of section .text$_ZSt4moveIRSsEONSt16remove_referenceIT_E4typeEOS2_:

00000000 <__ZSt4moveIRSsEONSt16remove_referenceIT_E4typeEOS2_>:
   *  @param  __t  A thing of arbitrary type.
   *  @return The parameter cast to an rvalue-reference to allow moving it.
  */
  template<typename _Tp>
    constexpr typename std::remove_reference<_Tp>::type&&
    move(_Tp&& __t) noexcept
   0:	55                   	push   ebp
   1:	89 e5                	mov    ebp,esp
    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
   3:	8b 45 08             	mov    eax,DWORD PTR [ebp+0x8]
   6:	5d                   	pop    ebp
   7:	c3                   	ret    

Disassembly of section .text$_ZN1AD1Ev:

00000000 <__ZN1AD1Ev>:
#include <utility>
#include <string>
using namespace std;

class A {
   0:	55                   	push   ebp
   1:	89 e5                	mov    ebp,esp
   3:	83 ec 18             	sub    esp,0x18
   6:	89 4d f4             	mov    DWORD PTR [ebp-0xc],ecx
   9:	8b 45 f4             	mov    eax,DWORD PTR [ebp-0xc]
   c:	89 c1                	mov    ecx,eax
   e:	e8 00 00 00 00       	call   13 <__ZN1AD1Ev+0x13>
  13:	c9                   	leave  
  14:	c3                   	ret    
  15:	90                   	nop
  16:	90                   	nop
  17:	90                   	nop