Q:

Copy and move through inheritance hierarchy

Consider a simple 
class Foo
{
public:
   Foo(const std::string& name) : _name{name}

private:
   std::string _name;
};

we know can be optimized by a copy and move
class Foo
{
public:
   Foo(std::string name) : _name{std::move(name)}

private:
   std::string _name;
};

but consider now the hierarchy:
class Base
{
protected:
   Base(const std::string& name) : _name{name}

private:
   std::string _name;
};

class Derived : public Base
{
public:
   Derived(const std::string& name) : A(name) {}
};

class Derived2 : public Derived
{
public:
   Derived2(const std::string& name) : Derived(name) {}
};

What is the correct way to implement the copy and swap idiom here? Does it even have sense use copy and swap rather than passing the const reference?
Edit: Please explains downvotes.

A:

Passing by const reference is still the conventional wisdom
And will in all likely-hood continue to be, see code guidelines concerning this.
Despite what you may read on blogs, etc. you should stick with passing const reference for all normal use cases of objects that can potentially be expensive to copy - semanticly you shouldn't need to worry about how type X performs move and copy wise. This is still the conventional wisdom that is recommended and gives the needed flexible to change implementations at a later stage. If you leave the code inline in the header, any decent compiler is able to optimize that anyway (or perhaps with whole program optimization if not in header).
Also, using the copy and move is only (sometimes) faster for rvalues - not lvalues. lvalues is actually now worse off and have to take a copy of the object first and then move it.
std::string is particularly interesting here due to small string optimization
- so for a lot of small strings that could in worst case be a performance degration of close to a factor 2. Why ? for small strings a move is as expensive as a copy and neither move or copy is trivial meaning an optimization miss if using the copy and move idiom.
In the linked to post from commments, the author also has to write:

That, again, is a cheap constant-time operation, whereas copying is a
  linear-time operation, so in many cases that will be a price well
  worth paying.

Also, not all types are cheap to move anyway (example std::array).
If and only if, you have had this shown up in a profiler and you are still really really concerned about it - then you probably want to use a forward reference && instead of the plain copy (if not the solution is something third) - then call std::forward for forwarding to base classes (perfect forwarding).

