std :: move Vs std :: forward

Esta parece ser a pergunta mais relevante já feita.

Qual é a diferença entre std :: move e std :: forward

Mas cada resposta é diferente e se aplica e diz coisas ligeiramente diferentes. Então, eu estou confuso.

Eu tenho a seguinte situação.

Copiar item para o contêiner
O item Copy é C ++ 03, então eu entendo isso muito bem.Construir item no container
O item Construir no contêiner, acredito, usa o encaminhamento perfeito corretamente para encaminhar os argumentos através de duas funções para o construtor de T ememplaceBackInternal() (Por favor, diga o contrário, se estiver errado).Mover item para o contêiner
Meu problema parece estar entendendo a movimentação de um item para o contêiner.

O código:

template<typename T>
class Container
{
    std::size_t length;
    T*          buffer;

public:
    void push_back(T const& value)
    {
         resizeIfRequired();
         pushBackInternal(value);
    }
    template<typename... Args>
    void emplace_back(Args&&... args)
    {
         resizeIfRequired();
         emplaceBackInternal(std::forward<T>(arg)...);
    }
    void push_back(T&& value)
    {
         resizeIfRequired();
         // Is this forward correct or should it be move
         moveBackInternal(std::forward<T>(value));
    }
private:
    void pushBackInternal(T const& value)
    {
         // Copy construct object into buffer;
         new (buffer + length) T(value);
         ++length;
    }
    template<typename... Args)
    void emplaceBackInternal(Args&&... args)
    {
         // Construct object into buffer using arguments;
         new (buffer + length) T(std::forward<T>(args)...);
         ++length;
    }
    void moveBackInternal(T&& value)
    {
         // Move construct object into buffer;
         // Is this forward correct or should it be move
         new (buffer + length) T(std::forward<T>(value));
         ++length;
    }
};

Incluo os três aqui para comparar as três funções com as respostas fornecidas na resposta mencionada anteriormente. A principal razão é quemove econstruct parece tão semelhante que parece que eles devem ser os mesmos.

Responda @Potatoswatter Pontuação 67

std :: forward possui um único caso de uso: para converter umparâmetro de função modelado

Por essa definição eu deveria estar usandostd::move dentropush_back(T&& value) emoveBackInternal(T&& value) como o valor não é um parâmetro de modelo para a função.

Responda @Howard Hinnant Pontuação 38

Se Y for uma referência lvalue, o resultado será uma expressão lvalue.Se Y não for uma referência de valor l, o resultado será um valor r (valor x para ser preciso).

Parece por esta definição que eu posso usarstd::move oustd::forward.

Responda @Bo Persson Pontuação 11

std :: forward é usado para encaminhar um parâmetro exatamente da maneira como foi passado para uma função.

Parece dizer questd::forward é aceitável (embora, se eu seguir o link na resposta, todos os exemplos usem funções modeladas).

questionAnswers(1)

yourAnswerToTheQuestion