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êinerO 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 em
emplaceBackInternal()
(Por favor, diga o contrário, se estiver errado).Mover item para o contêinerMeu 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).