const reference / rvalue reference overloads

{ Please replace tabs with spaces before posting. TIA., -mod/aps }

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_first_name( first_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_first_name( std::move( first_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".

The last sentence recalls forwarding. And in fact perfect forwarding
was the only thing I thought of to deal with this problem. Obviously
making Person constructor a template is not acceptable since it would
force us to deal with cumbersome error messages when incorrect
arguments are provided (like std::wstring which is easy with templates
as usually it is not clear what are the allowed types) and even more
importantly it would force us to keep implementation in header which
is often very undesired (due to dependency propagation and compilation
times).

It seems there is yet another trick. We could make a private function
to take only rvalue references. Such function can be placed in source
file normally as it is not template. And then provide a public
template forwarding function which would use some auxiliary template
magic to detect which arguments are passed by rvalue reference and
simple pass them further and which are passed by const reference and
construct a local object for them passing it further as rvalue
reference.

This seems to solve the problem. However to be usable with
constructors (like in this case) it requires ability to call a
different constructor overload from a constructor. (But this is to be
added to the language, isn't it?) Or to hide constructors and use
create functions.

Also another disadvantage of this solution is that the template
forwarding function would be rather complex (due to the auxiliary
templates to deal with arguments). Which enlarges not only the code
(to be read and understood) but also compilation time.

So are there any other tricks?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]