rvalue или lvalue (const) ссылочный параметр

Если я правильно понимаю ваш вопрос, вы хотите иметь одну функцию, параметр которой является либо ссылкой на rvalue (в случае предоставления rvalue), либо ссылкой lvalue на const (в случае предоставления lvalue).

Но что будет делать эта функция? Что ж, поскольку он должен быть в состоянии обрабатывать оба случая, включая случай, когда предоставляется lvalue, он не может изменять свои входные данные (по крайней мере, не тот, который привязан к параметру x) — если бы это было так, это нарушило бы семантику const ссылка.

Но опять же, если он не может изменить состояние параметра, нет причин разрешать ссылку rvalue: пусть x будет все время ссылкой lvalue на const. Ссылки lvalue на const могут связываться с rvalue, поэтому вам будет разрешено передавать как rvalue, так и lvalue.

Если семантика функции отличается в зависимости от того, что передается, то я бы сказал, что имеет смысл написать две такие функции: одну, которая принимает ссылку rvalue, и другую, которая принимает ссылку lvalue на const .

Как упомянул Энди, здесь важно то, что вы могли бы делать внутри своей функции, что имело бы смысл.

• Вы можете перенаправить аргументы в другую функцию. В этом случае использование шаблона не имеет значения, потому что, если задан неправильный тип параметра, он все равно вызовет ошибку компиляции (неправильные типы будут отправлены во вторую функцию). Вы можете использовать template <typename T> blah (T && x).
• Все остальное потребует от вас написания другого кода в зависимости от того, является ли это ссылкой на значение r или l, поэтому вам в любом случае нужно будет написать 2 функции: blah (const int & x) и blah (int && x).

Я предполагаю, что вы пытаетесь использовать первый вариант и пытаетесь сделать любые возможные ошибки компилятора более удобными для пользователя. Ну, я бы сказал, что оно того не стоит; программист все равно увидит список «вызывается…» в выводе любого приличного компилятора.

На самом деле, это очень хороший вопрос. До сих пор я также использовал трюк с универсальным эталоном плюс молоток enable_if. Здесь я представляю решение, которое не использует шаблоны и использует приведение lvalue в качестве альтернативы.

Далее следует реальный пример, когда ситуация возникает с использованием известного примера использования ofstream на месте, что невозможно (или очень сложно) в C++98 (я использую ostringstream в примере, чтобы сделать его более понятным).

Сначала вы увидите функцию по ссылке lvalue, как это часто бывает в C++98.

#include<iostream>
#include<sstream>
struct A{int impl_;};

std::ostringstream& operator<<(std::ostringstream& oss, A const& a){
    oss << "A(" << a.impl_ << ")"; // possibly much longer code.
    return oss;
}
// naive C++11 rvalue overload without using templates
std::ostringstream& operator<<(std::ostringstream&& oss, A const& a){
    oss << "A(" << a.impl_ << ")"; // ok, but there is code repetition.
    return oss;
}

int main() {

    A a{2};
    {// C++98 way
        std::ostringstream oss;
        oss << a;
        std::cout << oss.str() << std::endl; // prints "A(2)", ok"
    }
    {// possible with C++11, because of the rvalue overload
        std::cout << (std::ostringstream() << a).str() << std::endl; //prints "A(2)", ok
    }
}

Как видите, в C++11 мы можем добиться того, чего не можем в C++98. То есть использовать ostringstream (или ofstream) на месте. Теперь возникает вопрос OP, две перегрузки выглядят очень похожими, можно ли их объединить в одну?

Один из вариантов — использовать универсальную ссылку (Ostream&&) и, при необходимости, enable_if для ограничения типа. Не очень элегантно.

Что я обнаружил, используя этот пример «реального мира», так это то, что если вы хотите использовать один и тот же код для ссылки lvalue и ссылки rvalue, потому что, вероятно, вы можете преобразовать одно в другое!

std::ostringstream& operator<<(std::ostringstream&& oss, A const& a){
    return operator<<(oss, a);
}

Это выглядит как бесконечно рекурсивная функция, но это не так, потому что oss является ссылкой lvalue (да, это ссылка lvalue, потому что у нее есть имя). Таким образом, он вызовет другую перегрузку.

Вам по-прежнему нужно написать две функции, но у одной есть код, который вам не нужно поддерживать.

Таким образом, если «имеет смысл»© применять функцию как к (неконстантной) ссылке lvalue, так и к rvalue, это также означает, что вы можете преобразовать rvalue в lvalue и, следовательно, перенаправить к одной функции. Обратите внимание, что «это имеет смысл» зависит от контекста и значения предполагаемого кода, и это то, что мы должны «сказать» компилятору, явным образом вызвав перегрузку lvalue.

Я не говорю, что это лучше, чем использование универсальной ссылки, я говорю, что это альтернатива, и, возможно, намерение более ясно.

Редактируемый код здесь: http://ideone.com/XSxsvY. (обратная связь приветствуется)