Rvalue препратки и клас дизайн

Да, добавянето на претоварването string, както предлагате, е добра идея. Дори без препратки към rvalue такова претоварване би било добра идея. В противен случай, като се има предвид std::string s, за да го използвате, ще трябва:

x.set_data(s.c_str());

като има предвид, че

x.set_data(s);

е много по-интуитивен (и дори малко по-ефективен) за клиентите на X.

Като друга опция можете да добавите тези две претоварвания:

void set_data(const string& s) {internal = s;}
void set_data(string&& s)      {internal = std::move(s);}

Това е приблизително еквивалентно на единичното претоварване, което правилно предложихте. Има много леко предимство в производителността за решението с две претоварвания. Решението с единично претоварване ще струва допълнително string преместване, когато подаваният аргумент е xvalue (lvalue, която е преобразувана с std::move). Но конструкторът за преместване на std::string трябва да е много бърз, така че това не би трябвало да е голяма работа. Споменавам го само в духа на пълно разкриване.

Ако set_data има повече от един параметър, подходът "по стойност" става много по-привлекателен. Например разгледайте случая, когато трябва да преминете в две strings. Вашият избор е:

Разтвор 1

void set_data(string s1, string s2);

Решение 2

void set_data(const string&  s1, const string&  s2);
void set_data(      string&& s1, const string&  s2);
void set_data(const string&  s1,       string&& s2);
void set_data(      string&& s1,       string&& s2);

Както можете бързо да видите, Решение 2 се мащабира лошо с броя на параметрите.

И накрая, при никакви обстоятелства не трябва да се опитвате да приложите и двете решения към един и същи тип:

Не правете това!

void set_data(string s)        {internal = std::move(s);}
void set_data(const string& s) {internal = s;}
void set_data(string&& s)      {internal = std::move(s);}

Този набор от претоварвания ще бъде двусмислен. Точно както в C++03 следните две претоварвания са двусмислени:

void set_data(string s)        {internal = std::move(s);}
void set_data(const string& s) {internal = s;}

Никога не претоварвайте по-стойност с референция, нито референция lvalue, нито референция rvalue.

Не виждам причина да има и void set_data(const char* s) и void set_data(string s) като част от интерфейса. Това ще създаде неяснота и е предразположено към странични ефекти. Освен това вие все още предавате аргумента по стойност при извикване на set_data(string s). Вместо това бих предложил да дефинирате следните 2 функции:

void set_data(const string &s);
void set_data(string &&s);

По този начин можете да имате 2 реализации, първата ще копира дълбоко вашия низ, а втората може да открадне вътрешността на низа, тъй като е rvalue (не забравяйте да го оставите в дефинирано състояние, така че деструкторът да може да го унищожи без проблем - за подробности вижте http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2027.html#Move_Semantics).

Втората версия ще бъде извикана автоматично или при rvalue string аргумент, или ако аргументът е принуден да rvalue, например от std::move.

Ако искате да имате и опция по стойност, можете да използвате версията rvalue на този API, комбинирана с конструктор за копиране на низове: set_data(string(str)).