У меня есть код, который работает с вектором:
template<typename T>
void doVector(vector<T>& v, T&& value) {
//....
v.push_back(value);
//...
}
Для обычного push_back нужно ли использовать forward(value), move(value) или просто value (согласно новому С++ 11)? и как они влияют на производительность?
Например,
v.push_back(forward<T>(value));
Текущий код не будет компилироваться, если второй аргумент равен lvalue, потому что T&& окажется X&, что означает T должно быть X&, что в свою очередь означает, что std::vector<T> станет std::vector<X&> который не будет соответствовать первому аргументу, который равен std::vector<X> &. Следовательно, это ошибка.
Я бы использовал два параметра шаблона:
template<typename T, typename V>
void doVector(vector<T> & v, V && value)
{
v.emplace_back(std::forward<V>(value));
}
Так как V может быть другого типа из T, поэтому emplace_back имеет больше смысла, потому что не только он решает проблему, но и делает код более общим.: -)
Теперь следующее улучшение: поскольку мы используем emplace_back, который создает объект типа T из аргумента value (возможно, используя конструктор), мы могли бы воспользоваться этим фактом и сделать его вариационной функцией:
template<typename T, typename ...V>
void doVector(vector<T> & v, V && ... value)
{
v.emplace_back(std::forward<V>(value)...);
}
Это еще более общее, поскольку вы можете использовать его как:
struct point
{
point(int, int) {}
};
std::vector<point> pts;
doVector(pts, 1, 2);
std::vector<int> ints;
doVector(ints, 10);
Надеюсь, что это поможет.
forward(value) используется, если вам нужно совершенное значение пересылки, сохраняя такие вещи, как l-value, r-value.
пересылка очень полезна, потому что она может помочь вам избежать написания нескольких перегрузок для функций, где существуют различные комбинации l-val, r-val и ссылочных аргументов
move(value) на самом деле является типом оператора литья, который передает значение l в значение r
С точки зрения производительности, избегайте создания дополнительных копий объектов, которые являются основным преимуществом.
Таким образом, они действительно выполняют две разные вещи.
Когда вы говорите обычный push_back, я не уверен, что вы имеете в виду, вот две подписи.
void push_back( const T& value );
void push_back( T&& value );
первый, вы можете просто передать любой нормальный l-val, но для второго вам придется "переместить" l-val или переслать r-val. Имейте в виду, как только вы перемещаете l-val, вы не можете его использовать.
Для бонуса здесь есть ресурс, который, по-видимому, очень хорошо объясняет концепцию r-val-refs и других понятий, связанных с ними.
Как и другие, вы также можете переключиться на использование emplace, поскольку он действительно идеально подходит для аргументов конструктора объектов, что означает, что вы можете передать его, как хотите.
std::forward.std::move.например.
template <typename T>
void funcA(T&& t) {
funcC(std::forward<T>(t)); // T is deduced and therefore T&& means forward-ref.
}
void funcB(Foo&& f) {
funcC(std::move(f)); // f is r-value, use move.
}
Здесь отличное видео Скотта Мейерса, объясняющего пересылку ссылок (которые он называет универсальными ссылками), и когда использовать идеальную пересылку и/или std::move:
С++ и Beyond 2012: Скотт Майерс - Универсальные ссылки в С++ 11
Также см. этот связанный вопрос для получения дополнительной информации об использовании std::forward: Преимущества использования переадресации
В этом видео, IMO, есть лучшее объяснение того, когда следует использовать std:: forward и когда использовать std:: move. В нем представлена идея универсальной ссылки, которая является ИМО чрезвычайно полезным инструментом для рассуждения о семантике перемещения.