移动语义是 C++11 引入的一项特性,通过右值引用(Rvalue Reference)实现。它的目标是提高对于临时对象或即将销毁的对象的效率,避免不必要的深拷贝,而是在必要的时候将资源所有权从一个对象转移到另一个对象。
移动语义的关键在于对于右值引用的使用,它使用 &&
表示。在移动语义中,有两个主要的概念:移动构造函数和移动赋值运算符。
移动构造函数是一种特殊的构造函数,它允许将一个对象的资源(例如动态分配的内存、文件句柄等)从一个对象移动到另一个对象,而不是进行深拷贝。
代码示例:
class MyClass {
public:
// 移动构造函数
MyClass(MyClass&& other) noexcept {
// 移动资源的所有权
resource = other.resource;
other.resource = nullptr;
}
// 其他成员函数和构造函数省略
private:
int* resource; // 假设 resource 是需要移动的资源
};
移动赋值运算符用于将一个对象的资源移动到另一个对象,类似于移动构造函数,但是它在对象已经存在的情况下使用。
class MyClass {
public:
// 移动赋值运算符
MyClass& operator=(MyClass&& other) noexcept {
if (this != &other) {
// 释放当前对象的资源
delete resource;
// 移动资源的所有权
resource = other.resource;
other.resource = nullptr;
}
return *this;
}
// 其他成员函数和构造函数省略
private:
int* resource; // 假设 resource 是需要移动的资源
};
move 是 C++ 标准库中定义的一个函数模板,位于头文件
中。它用于将一个左值转换为右值引用,主要用于支持移动语义。move 并不实际进行移动操作,它只是通过类型转换告诉编译器,我们允许对这个左值进行移动操作。
move函数的实现代码:
namespace std {
template
constexpr remove_reference_t&& move(T&& arg) noexcept {
return static_cast&&>(arg);
}
}
std::move
接受一个模板参数 T
,并返回一个 T&&
类型的右值引用。它实际上是通过 static_cast
进行类型转换的。在右值引用&&的特性中介绍到, T&&作为函数参数, 可以推到为左值引用
这里使用了 static_cast
将 T&&
转换为 remove_reference_t
。remove_reference_t
是一个模板元编程工具,用于移除引用。这个转换告诉编译器,我们希望将传入的左值引用 arg
转换为右值引用。
#include
#include
class MyString {
public:
// 普通构造函数
MyString(const char* data) : size(std::strlen(data)), str(new char[size + 1]) {
std::cout << "普通构造函数" << std::endl;
strcpy_s(str, size + 1, data);
}
// 移动构造函数
MyString(MyString&& other) noexcept : size(other.size), str(other.str) {
std::cout << "移动构造函数" << std::endl;
other.size = 0;
other.str = nullptr;
}
// 移动赋值运算符
MyString& operator=(MyString&& other) noexcept {
std::cout << "移动赋值运算" << std::endl;
if (this != &other) {
delete[] str;
size = other.size;
str = other.str;
other.size = 0;
other.str = nullptr;
}
return *this;
}
// 打印字符串
void print() const {
std::cout << "String: " << (str ? str : "null") << std::endl;
}
~MyString() {
delete[] str;
}
private:
size_t size;
char* str;
};
int main() {
MyString a("Hello"); // 普通构造函数
a.print();
MyString b(std::move(a)); // 移动构造函数
a.print(); // null
b.print();
// MyString c = b; // error 移动构造函数, = 右边应该是一个右值
MyString c = std::move(b); // 移动构造
a = MyString("World"); // 普通构造函数 + 移动赋值运算符
// MyString("World") 属于是一个用普通构造创建的一个右值, 通过=赋值给a
a.print();
return 0;
}
输出结果为:
普通构造函数
String: Hello
移动构造函数
String: null
String: Hello
移动构造函数
普通构造函数
移动赋值运算
String: World
MyString b(std::move(a)); // 移动构造函数
a.print(); // null
a已经将资源转移给b了, 打印a输出null
完美转发是 C++11 引入的一个重要特性,它允许在模板中精确地保持函数参数的值类别(左值还是右值),并将它们传递到其他函数。完美转发通常用于实现泛型代码,特别是在编写通用函数模板时非常有用。
完美转发的核心在于使用通用引用(Universal Reference)和引用折叠。通用引用的语法是 T&&
,其中 T
是模板参数。引用折叠是指在模板类型推导或类型声明的过程中,两个引用(无论是左值引用还是右值引用)可能折叠成一个引用。
代码示例:
#include
#include
// 用于演示的一个简单处理函数
void process(int& x) {
std::cout << "Lvalue reference: " << x << std::endl;
}
void process(int&& x) {
std::cout << "Rvalue reference: " << x << std::endl;
}
// 完美转发函数模板
template
void forwarder(T&& arg) {
// 在这里可以根据 arg 的值类别进行处理
process(std::forward(arg));
}
int main() {
int x = 42;
forwarder(x); // 传递左值
forwarder(123); // 传递右值
return 0;
}
输出为:
Lvalue reference: 42
Rvalue reference: 123
在这个例子中,forwarder
是一个接受通用引用的函数模板,它调用 process
函数并使用 std::forward
来完美转发参数。process
函数有两个重载版本,分别接受左值引用和右值引用。
通过 forwarder(x)
调用时,T
被推导为 int&
,从而调用了接受左值引用的 process
版本。通过 forwarder(123)
调用时,T
被推导为 int
,从而调用了接受右值引用的 process
版本。(详细说明可以看下面的forward函数)
在实际使用中,完美转发通常结合模板参数包(Template Parameter Pack)和 std::forward
使用,以处理任意数量和类型的参数。这使得编写通用的函数模板成为可能,可以适应各种情况。
这里从另一个角度说一下完美转发和forward函数
右值引用类型是独立于值的,一个右值引用作为函数参数的形参时,在函数内部转发该参数给内部其他函数时,它就变成一个左值,并不是原来的类型了。如果需要按照参数原来的类型转发到另一个函数,可以使用C++11提供的std::forward()函数,该函数实现的功能称之为完美转发。
函数原型如下:
// 函数原型
template T&& forward (typename remove_reference::type& t) noexcept;
template T&& forward (typename remove_reference::type&& t) noexcept;
// 精简之后的样子
std::forward(t);
重点:
代码示例:
#include
using namespace std;
template
void printValue(T& t)
{
cout << "l-value: " << t << endl;
}
template
void printValue(T&& t)
{
cout << "r-value: " << t << endl;
}
template
void testForward(T && v)
{
printValue(v);
printValue(move(v));
printValue(forward(v));
cout << endl;
}
int main()
{
testForward(520);
int num = 1314;
testForward(num);
testForward(forward(num));
testForward(forward(num));
testForward(forward(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
testForward(520);函数的形参为未定引用类型T&&,实参为右值,初始化后被推导为一个右值引用
printValue(v);已命名的右值v,编译器会视为左值处理,实参为左值
printValue(move(v));已命名的右值编译器会视为左值处理,通过move又将其转换为右值,实参为右值
printValue(forward(v));forward的模板参数为右值引用,最终得到一个右值,实参为右值
testForward(num);函数的形参为未定引用类型T&&,实参为左值,初始化后被推导为一个左值引用
printValue(v);实参为左值
printValue(move(v));通过move将左值转换为右值,实参为右值
printValue(forward(v));forward的模板参数为左值引用,最终得到一个左值引用,实参为左值
testForward(forward(num));forward的模板类型为int,最终会得到一个右值,函数的形参为未定引用类型T&&被右值初始化后得到一个右值引用类型
printValue(v);已命名的右值v,编译器会视为左值处理,实参为左值
printValue(move(v));已命名的右值编译器会视为左值处理,通过move又将其转换为右值,实参为右值
printValue(forward(v));forward的模板参数为右值引用,最终得到一个右值,实参为右值
testForward(forward
printValue(v);实参为左值
printValue(move(v));通过move将左值转换为右值,实参为右值
printValue(forward(v));forward的模板参数为左值引用,最终得到一个左值,实参为左值
testForward(forward
printValue(v);已命名的右值v,编译器会视为左值处理,实参为左值
printValue(move(v));已命名的右值编译器会视为左值处理,通过move又将其转换为右值,实参为右值
printValue(forward(v));forward的模板参数为右值引用,最终得到一个右值,实参为右值