Какой тип должна принимать шаблонная функция, если я хочу, чтобы

она принимала const std::string& и std::string&&?
P.S. У Мейерса этот момент не совсем понял

universal reference. с двумя амперсандами

Понял. Тогда немного не понял про обычный lvalue reference в шаблонах для rvalue. Вот что он пишет: "Все эти примеры показывают ссылочные параметры, являющиеся lvalue, но вывод типа точно так же работает и для ссылочных параметров rvalue. Конечно, rvalue-аргументы могут передаваться только ссылочным параметрам, являющимся rvalue, но это ограничение никак не влияет на вывод типов" В общем, вот его пример template<typename T> void f(T& param); int x = 27; int& rx = x; f(rx); // тип T - int, тип param - int& Что будет в случае с f(std::move(x))?

С большой вероятностью нужен просто std::string by value

Так копирование будет

Поясню: если принимающему методу нужна строка для владения (ну, а какой ещё смысл может быть от std::string&& перегрузки?), то пара const std::string& + std::string&& ничем* не лучше одной функции с std::string

Почему? Если вызов будет func("Бла-бла"), то будет копирование же, нет? А если func(s), то будет копирование

func("Бла-бла") - копирования не будет, будет мув.

🤔

Ну а для func(s) будет в одном случае копирование или внутри функции (если принимать const std::string& и копировать внутри), или снаружи (если принимать по значению). Итого - копий одинаковое кол-во.

тут просто надо помнить правила слияния ссылок. у тебя T = int&&, следовательно T& = int&& & = int&. Значит ты передашь параметр по обычной ссылке

Ну с этим всё понятно

Заставляет сильно задуматься

Да если подумаешь, то всё оказывается просто и понятно

Ну можно и без правил свертки ссылок нормально жить я думаю

что бы понять как работает perfect forwarding и почему foo(T&) принимает только rvalue ссылки, правила нужно знать

Ну мне нормально и объяснения Мейерса с универсальной ссылкой

int && a = 5; auto& x = a; // int&?

речь же про эту статью? https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers

Да

не

int

Because there are two kinds of references (lvalue references and rvalue references), there are four possible reference-reference combinations: lvalue reference to lvalue reference, lvalue reference to rvalue reference, rvalue reference to lvalue reference, and rvalue reference to rvalue reference. There are only two reference-collapsing rules: An rvalue reference to an rvalue reference becomes (“collapses into”) an rvalue reference. All other references to references (i.e., all combinations involving an lvalue reference) collapse into an lvalue reference.

Поправил, извините

Хз что это меняет

Ничего не меняет. Просто Скотт Мейрес рассказывает про правила свёртки в статье про perfect forwarding

Да. Тут теже правила используются int & lvalue = ...; int && rvalue = ...; auto& x1 = lvalue; // int& auto&& x1 = lvalue; // int& auto& x2 = rvalue; // int& auto&& x2 = std::move(rvalue); //int&&

auto& x2 = std::move(rvalue); // int& ну ну)

Да, поторопился

О, теперь понял. int a = 5; auto&& b = std::move(a); // int&&?

Ага. Но при этом auto&& b = a; //int&

Да, дошло