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

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

• 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 аргументы являются временными выражениями, и поэтому они будут пересылаться как rvalue. Но мы также могли бы смешать именованные объекты в вызове конструктора, как в ситуации №4, и тогда нам потребуется пересылка как lvalue.

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