Могу я обычно/всегда использовать std:: forward вместо std:: move?

Я наблюдал за Скоттом Майерсом на Universal Libraries на конференции С++ и Beyond 2012, и все имеет смысл до сих пор. Тем не менее, член аудитории задает вопрос примерно через 50 минут, о котором мне также было интересно. Мейерс говорит, что он не заботится о ответе, потому что он не идиоматичен и глупо его ум, но меня все еще интересует.

Представленный код выглядит следующим образом:

// Typical function bodies with overloading:
void doWork(const Widget& param)   // copy
{
  // ops and exprs using param
}
void doWork(Widget&& param)        // move
{
  // ops and exprs using std::move(param)
}

// Typical function implementations with universal reference:
template <typename T>
void doWork(T&& param)             // forward => copy and move
{
  // ops and exprs using std::forward<T>(param)
}

Точка заключается в том, что, когда мы берем ссылку на rvalue, мы знаем, что у нас есть rvalue, поэтому нам нужно std::move сохранить тот факт, что это rvalue. Когда мы берем универсальную ссылку (T&&, где T - выведенный тип), мы хотим, чтобы std::forward сохранял тот факт, что это могло быть lvalue или rvalue.

Итак, возникает вопрос: поскольку std::forward сохраняет ли значение, переданное в функцию, либо значение lvalue, либо rvalue, а std::move просто передает свой аргумент в rvalue, можно ли просто использовать std::forward всюду? Будет ли std::forward вести себя как std::move во всех случаях, когда мы будем использовать std::move, или есть некоторые важные отличия в поведении, которые упускаются из-за обобщения Мейерса?

Я не предполагаю, что кто-то должен это делать, потому что, как правильно говорит Мейерс, он полностью не идиоматичен, но также является допустимым использованием std::move:

void doWork(Widget&& param)         // move
{
  // ops and exprs using std::forward<Widget>(param)
}

Ответ 1

Эти два являются очень разными и взаимодополняющими инструментами.

std::move выводит аргумент и безоговорочно создает выражение rvalue. Это имеет смысл применить к реальному объекту или переменной.
std::forward принимает обязательный аргумент шаблона (вы должны указать это!) и магически создает ссылку на lvalue или выражение rvalue в зависимости от того, какой тип был (в силу добавления && и правил свертывания), Это имеет смысл только применить к вычисленному аргументу аргументированной функции.

Возможно, следующие примеры иллюстрируют это немного лучше:

#include <utility>
#include <memory>
#include <vector>
#include "foo.hpp"

std::vector<std::unique_ptr<Foo>> v;

template <typename T, typename ...Args>
std::unique_ptr<T> make_unique(Args &&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));  // #1
}

int main()
{
    {
        std::unique_ptr<Foo> p(new Foo('a', true, Bar(1,2,3)));
        v.push_back(std::move(p));                                  // #2
    }

    {
        v.push_back(make_unique<Foo>('b', false, Bar(5,6,7)));      // #3
    }

    {
        Bar b(4,5,6);
        char c = 'x';
        v.push_back(make_unique<Foo>(c, b.ready(), b));             // #4
    }
}

В ситуации №2 у нас есть существующий, конкретный объект p, и мы хотим безоговорочно перейти от него. Только std::move имеет смысл. Здесь нечего "переезжать". У нас есть именованная переменная, и мы хотим перейти от нее.

С другой стороны, ситуация # 1 принимает список любых аргументов, и каждый аргумент должен быть перенаправлен как та же категория значений, что и в исходном вызове. Например, в # 3 аргументы являются временными выражениями, и поэтому они будут перенаправлены как rvalues. Но мы могли бы также смешать именованные объекты в вызове конструктора, как в ситуации №4, а затем нам нужно переадресовать как lvalues.

Ответ 2

Да, если param является Widget&&, то следующие три выражения эквивалентны (если предположить, что Widget не является ссылочным типом):

std::move(param)
std::forward<Widget>(param)
static_cast<Widget&&>(param)

В общем случае (когда Widget может быть ссылкой), std::move(param) эквивалентно обоим следующим выражениям:

std::forward<std::remove_reference<Widget>::type>(param)
static_cast<std::remove_reference<Widget>::type&&>(param)

Заметьте, насколько приятнее std::move для перемещения материала. Точка std::forward заключается в том, что она хорошо сочетается с правилами вывода типа шаблона:

template<typename T>
void foo(T&& t) {
    std::forward<T>(t);
    std::move(t);
}

int main() {
    int a{};
    int const b{};
               //Deduced T   Signature    Result of `forward<T>` Result of `move`
    foo(a);    //int&        foo(int&)       lvalue int          xvalue int
    foo(b);    //int const&  foo(int const&) lvalue int const    xvalue int const
    foo(int{});//int         foo(int&&)      xvalue int          xvalue int
}