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

Я наблюдал за Скоттом Мейерсом говорить на универсальные ссылки С конференции C++ и за ее пределами 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)
}
2 62
c++ c++11 move-semantics perfect-forwarding rvalue-reference

2 ответа:

эти два очень разные и дополнительных инструменты.

  • 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.

68

да, если 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
}
14