转移和完美转发
文章目录
- 转移和完美转发
- std::move
- 作用
- 使用方法
- std::forward
- 作用
- 使用方法
std::move
std::move 是 C++11 引入的一个标准库函数，主要用于将一个对象标记为“可移动”的状态，从而允许资源的转移而不是复制。
作用
- 资源转移：当一个对象被
std::move标记后，编译器会尝试使用移动语义（move semantics）来转移资源，而不是进行深拷贝。 - 性能优化：对于大型对象或包含动态分配资源的对象，使用
std::move可以显著提高性能，因为移动操作通常比复制操作更高效。 - 使用std::move方法可以将左值转换为右值。使用这个函数并不能移动任何东西，而是和移动构造函数一样都具有移动语义，将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存拷贝。
使用方法
- 基本语法：
T&& rvalue = std::move(lvalue);
其中 lvalue 是一个左值（具有持久生命周期的对象），std::move 将其转换为右值引用（rvalue reference）。
- 使用方法：
class Test
{
public：
Test(){}
......
}
int main()
{
Test t;
Test && v1 = t; // error
Test && v2 = move(t); // ok
return 0;
}
1. 在第10行中，使用左值初始化右值引用，因此语法是错误的
2. 在第11行中，使用move()函数将左值转换为了右值，这样就可以初始化右值引用了。
假设一个临时容器很大，并且需要将这个容器赋值给另一个容器，就可以执行如下操作：
list<string> ls;
ls.push_back("hello");
ls.push_back("world");
......
list<string> ls1 = ls; // 需要拷贝, 效率低
list<string> ls2 = move(ls);
如果不使用std::move，拷贝的代价很大，性能较低。使用move几乎没有任何代价，只是转换了资源的所有权。如果一个对象内部有较大的堆内存或者动态数组时，使用move()就可以非常方便的进行数据所有权的转移。另外，我们也可以给类编写相应的移动构造函数（T::T(T&& another)）和和具有移动语义的赋值函数（T&& T::operator=(T&& rhs)），在构造对象和赋值的时候尽可能的进行资源的重复利用，因为它们都是接收一个右值引用参数。
std::forward
std::forward 是 C++11 引入的一个标准库函数，主要用于完美转发（perfect forwarding）。完美转发是指在模板函数中，将参数原封不动地传递给另一个函数，保留其左值或右值属性。
作用
- 保留参数类型：确保参数在传递过程中保持其原始的左值或右值特性。(T:参数）
- 当T为左值引用类型时，t将被转换为T类型的左值
- 当T不是左值引用类型时，t将被转换为T类型的右值
- 灵活性：使得模板函数能够处理不同类型的参数，而不会丢失其原始属性。
使用方法
- 基本语法：
T&& forward(remove_reference_t<T>& t) noexcept;
T&& forward(remove_reference_t<T>&& t) noexcept;
其中 T 是模板参数类型。
- 示例： 假设有一个模板函数
foo，它接受一个通用参数并将其传递给另一个函数bar：
template <typename T>
void foo(T&& param) {
bar(std::forward<T>(param));
}
void bar(int& x) {
std::cout << "Lvalue reference" << std::endl;
}
void bar(int&& x) {
std::cout << "Rvalue reference" << std::endl;
}
int main() {
int x = 42;
foo(x); // 输出: Lvalue reference
foo(42); // 输出: Rvalue reference
return 0;
}
- 下面通过一个例子演示一下关于forward的使用:
#include <iostream>
using namespace std;
template<typename T>
void printValue(T& t)
{
cout << "l-value: " << t << endl;
}
template<typename T>
void printValue(T&& t)
{
cout << "r-value: " << t << endl;
}
template<typename T>
void testForward(T && v)
{
printValue(v);
printValue(move(v));
printValue(forward<T>(v));
cout << endl;
}
int main()
{
testForward(520);
int num = 1314;
testForward(num);
testForward(forward<int>(num));
testForward(forward<int&>(num));
testForward(forward<int&&>(num));
return 0;
}
===== 输出：
l-value: 520
r-value: 520
r-value: 520
l-value: 1314
r-value: 1314
l-value: 1314
l-value: 1314
r-value: 1314
r-value: 1314
l-value: 1314
r-value: 1314
l-value: 1314
l-value: 1314
r-value: 1314
r-value: 1314
1. testForward(520);函数的形参为未定引用类型T&&，实参为右值，初始化后被推导为一个右值引用
1. printValue(v);已命名的右值v，编译器会视为左值处理，实参为左值
2. printValue(move(v));已命名的右值编译器会视为左值处理，通过move又将其转换为右值，实参为右值
3. printValue(forward<T>(v));forward的模板参数为右值引用，最终得到一个右值，实参为 右值
2. testForward(num);函数的形参为未定引用类型T&&，实参为左值，初始化后被推导为一个左值引用
1. printValue(v);实参为左值
2. printValue(move(v));通过move将左值转换为右值，实参为右值
3. printValue(forward<T>(v));forward的模板参数为左值引用，最终得到一个左值引用，实参为左值
3. testForward(forward<int>(num));forward的模板类型为int，最终会得到一个右值，函数的形参为未定引用类型T&&被右值初始化后得到一个右值引用类型
1. printValue(v);已命名的右值v，编译器会视为左值处理，实参为左值
2. printValue(move(v));已命名的右值编译器会视为左值处理，通过move又将其转换为右值，实参为右值
3. printValue(forward<T>(v));forward的模板参数为右值引用，最终得到一个右值，实参为右值
4. testForward(forward<int&>(num));forward的模板类型为int&，最终会得到一个左值，函数的形参为未定引用类型T&&被左值初始化后得到一个左值引用类型
1. printValue(v);实参为左值
2. printValue(move(v));通过move将左值转换为右值，实参为右值
3. printValue(forward<T>(v));forward的模板参数为左值引用，最终得到一个左值，实参为左值
5. testForward(forward<int&&>(num));forward的模板类型为int&&，最终会得到一个右值，函数的形参为未定引用类型T&&被右值初始化后得到一个右值引用类型
1. printValue(v);已命名的右值v，编译器会视为左值处理，实参为左值
2. printValue(move(v));已命名的右值编译器会视为左值处理，通过move又将其转换为右值，实参为右值
3. printValue(forward<T>(v));forward的模板参数为右值引用，最终得到一个右值，实参为右值
