#include <iostream>

using namespace std;

class C
{
public:
	C(){}
	C(const C& c){ cout<<"copy ctor of C invoked."<<endl;}
};

class CM
{
public:
	CM(){}
	CM(const CM& c){ cout<<"copy ctor of CM invoked."<<endl;}
	CM(CM&& c){ cout<<"move ctor of CM invoked."<<endl;}
};

C&& ReturnC(){ return C(); }
CM&& ReturnCM(){ return CM(); }

int main()
{
	C c=ReturnC();
	CM cm=ReturnCM();
}

#include <iostream>

using namespace std;

class CM
{
public:
	CM(){cout<<"CM default ctor invoked"<<endl;}
	CM(const CM& c){ cout<<"copy ctor of CM invoked."<<endl;}
	CM(CM&& c){ cout<<"move ctor of CM invoked."<<endl;}
};

class CMD : public CM
{
public:
	CMD(){cout<<"CMD default ctor invoked"<<endl;}
	CMD(const CMD& c){ cout<<"copy ctor of CMD invoked."<<endl;}
	CMD(CMD&& c){ cout<<"move ctor of CMD invoked."<<endl;}
	
};


int main()
{
	CMD cm;
	
	cout<<"------------------------"<<endl;
	
	CMD cmd=std::move(cm);
}

CM default ctor invoked
CMD default ctor invoked
------------------------
CM default ctor invoked
move ctor of CMD invoked.

#include <iostream>

using namespace std;

class CM
{
public:
	CM(){cout<<"CM default ctor invoked"<<endl;}
	CM(const CM& c){ cout<<"copy ctor of CM invoked."<<endl;}
	CM(CM&& c){ cout<<"move ctor of CM invoked."<<endl;}
};

class CMD : public CM
{
public:
	CMD(){cout<<"CMD default ctor invoked"<<endl;}
	CMD(const CMD& c){ cout<<"copy ctor of CMD invoked."<<endl;}
	CMD(CMD&& c):CM(std::move(c)){ cout<<"move ctor of CMD invoked."<<endl;}
};

int main()
{
	CMD cm;
	
	cout<<"------------------------"<<endl;
	
	CMD cmd=std::move(cm);
}

CM default ctor invoked
CMD default ctor invoked
------------------------
move ctor of CM invoked.
move ctor of CMD invoked.

struct base
{
    base() : buff(nullptr), buff_len(0u){}
    
    // copy ctor
    base(const base& b): buff_len(b.buff_len)
    {
        if(buff_len)
        {
             buff=new char[buff_len];
             memcpy(buff,b.buff,buff_len);
        }else
             buff=nullptr;  
    }

    // move ctor, essentially do what Upp-pick is supposed to do
    base(base&& b):buff_len(b.buff_len), buff(b.buff)
    {
           b.buff_len=0u;
           b.buff=nullptr;
    }

private:
    char * buff;
    unsigned buff_len;
};

struct derived : public base
{
     derived(): i(0){} // will call base::default ctor to consturct base part of *this;

     derived(const derived& d) : i(d.i) {} // will call base::copy ctor to construct base part of *this;

     derived(derived&& d): i(d.i){} // you may expect base::move ctor to be called to construct base part of *this.
                       // I do think the c++ committee should default to use base move ctor for derived move ctor.
                       // unfortunately, this is not the case. you have to explicitly delegate the construction of
                       // the base part of *this to base move ctor, with something like this:
                       //   
                       //  derived(derived&& d) : base(std::move(d)), i(d.i){}
                       //
                       // this is the point I was trying to make.

private:
     int i;
};