Re: const reference / rvalue reference overloads

Doesn't extensive use of rvalue references cause lots of overloads
of functions (in particular creation functions and constructors)? It
seems so to me. Lets consider this example:

class Person
{
public:
Person(
const std::string& first_name,
const std::string& last_name
)


  m_last_name( last_name )
{
}

const std::string& get_first_name() const
{
return m_first_name;
}

const std::string& get_last_name() const
{
return m_last_name;
}

private:
const std::string& m_first_name;
const std::string& m_last_name;

};

A very simple class. Correctly takes first_name and last_name as
const reference to avoid copying. (Although we might have used
simple values and swapping - however this requires a good swap
function which cannot be assumed in general.)

But we have now rvalue references which are even better so why not
to use them by adding additional constructor:

Person(
std::string&& first_name,
std::string&& last_name
)


  m_last_name( std::move( last_name ) )
{
}

All seems fine. We have a cool state-of-the-art code and so on. But
our eyes open in the moment we write following code:

void f( const Person& someone )
{
Person temp(
get_random_rvalue_first_name(),
someone.get_last_name()
);
}

This code no longer works as good. First argument is an rvalue
reference while second is an ordinary const reference. This results
in a call to the const reference constructor and no gain from
moving the rvalue. So it becomes clear we have to add yet another
two constructor overloads to cover all 4 cases. But it would be 8
and 16 with 3 and 4 arguments. It is obviously not acceptable.

So either Person will keep using old const references or it will
have to provide lots of overloads to cover all cases. It is not a
good situation.

How can be this overcome? It is possible to deal with it somehow?
What is needed is a way to say somehow "get whatever suits best and
pass it further".