Do I need to overload methods accepting const lvalue reference for rvalue references explicitly?

Question

currently I'm playing around with rvalue reference (C++11, g++ with gnu++x0) and I want to implement move semantics in my classes, because it just feels „right“.

Do I need to overload each function which normally would accept const lvalue reference to benefit from the rvalue references?

Let's say this is my example class:

class Person {
public:
    Person() = default;
    Person(std::string &name);
    Person(const Person &rhs);
    Person(Person &&rhs);

    Person& operator=(const Person &rhs);
    Person& operator=(Person &&rhs);

    std::string& get_name() const;
    void set_name(const std::string &name);
private:
    std::string name_;
}

/* snip */

void Person::set_name(const std::string &name)
{
    this->name_ = name;
}

I now want to use the setter with rvalue references and eliminate unnecessary copies.

Person test("Jon Doe");
test.set_name("Jon Doe2");

Do I really need to overload every method this way?

void Person::set_name(std::string &&name)
{
    this->name_ = std::move(name);
}

This seems very redundant to me. Is there any way to implement this easier?

Thanks!

(I read stackoverflow often, but this is my first question. So please give me hint if I'm doing something wrong.)

Answer 1

Write one function. Take it in by value, then move it.

void Person::set_name(std::string name)
{
    this->name_ = std::move(name);
}

Let the std::string decide how to copy itself.