1. 移动语义（Move Semantics）是C++11引入的一个重要特性，用于优化对象的拷贝和资源管理。它通过将资源的所有权从一个对象转移给另一个对象，避免了不必要的拷贝构造和析构操作，提高程序的效率。
移动语义的关键在于右值引用（Rvalue Reference）和移动构造函数（Move Constructor）。
下面是一个示例代码来说明移动语义的应用：
#include <iostream>
#include <utility>
// 示例类，管理一个动态分配的资源
class MyArray {
public:
// 构造函数，申请资源
MyArray(std::size_t len) : length(len) {
data = new int[length];
for (std::size_t i = 0; i < length; ++i) {
data[i] = i + 1;
}
std::cout << "Constructed, length = " << length << std::endl;
}
// 移动构造函数，转移资源的所有权
MyArray(MyArray&& other) noexcept : data(other.data), length(other.length) {
other.data = nullptr;
other.length = 0;
std::cout << "Moved, length = " << length << std::endl;
}
// 析构函数，释放资源
~MyArray() {
delete[] data;
std::cout << "Destructed, length = " << length << std::endl;
}
// 输出数组内容
void print() const {
for (std::size_t i = 0; i < length; ++i) {
std::cout << data[i] << ' ';
}
std::cout << std::endl;
}
private:
int* data;
std::size_t length;
};
int main() {
MyArray arr1(5);
MyArray arr2(std::move(arr1)); // 移动构造函数，将arr1的资源转移给arr2
std::cout << "arr1: ";
arr1.print(); // 输出: arr1:
std::cout << "arr2: ";
arr2.print(); // 输出: arr2: 1 2 3 4 5
return 0;
}
在上面的示例中，我们定义了一个简单的类 MyArray，它管理一个动态分配的整数数组作为成员变量。它的构造函数用于申请资源并初始化数组的内容，移动构造函数用于转移资源的所有权，析构函数用于释放资源。
在 main 函数中，我们首先创建一个 arr1 对象，它的构造函数申请了一个长度为5的整数数组，并初始化其内容。然后，我们使用 std::move 将 arr1 的资源转移给了 arr2，这时调用了移动构造函数。在输出中，我们可以看到 arr1 变成了空数组，而 arr2 保留了原始数组的内容。
通过移动语义，我们可以实现资源的高效转移，避免不必要的拷贝构造和析构操作，提高程序的性能。这对于管理动态分配的内存、IO缓冲区或其他资源非常有用。
2. 完美转发（Perfect Forwarding）是C++11中的一个重要特性，它允许将函数模板中的参数完全转发给内部的另一个函数，同时保持原始参数的值类别和常量性。这样可以实现通用性更强的函数调用语义，尤其在涉及函数参数转发的情况下非常有用。
完美转发的实现主要依赖于两个关键要素：右值引用（Rvalue Reference）和 std::forward 函数模板。
下面是一个示例代码来说明完美转发的应用：
#include <iostream>
#include <utility>
// 内部函数，对不同类型的参数进行处理
void process(int& x) {
std::cout << "Lvalue reference: " << x << std::endl;
}
void process(int&& x) {
std::cout << "Rvalue reference: " << x << std::endl;
}
// 完美转发函数模板，用于将参数转发到内部函数中
template <typename T>
void forward(T&& x) {
process(std::forward<T>(x));
}
int main() {
int a = 10;
forward(a); // 传递左值 a，调用 process(int& x)，输出：Lvalue reference: 10
forward(20); // 传递右值 20，调用 process(int&& x)，输出：Rvalue reference: 20
forward(std::move(a)); // 传递右值引用 a，调用 process(int&& x)，输出：Rvalue reference: 10
return 0;
}
在上面的示例中，我们定义了两个重载的 process 函数，一个接受左值引用参数，另一个接受右值引用参数。然后，我们定义了一个完美转发函数模板 forward，它的参数类型是一个通用引用（T&&）。
在 forward 函数内部，我们使用 std::forward<T>(x) 将传递给 forward 的参数 x 转发给 process 函数。std::forward 是一个由标准库提供的模板函数，它会根据 T 的值类别（左值还是右值）来决定返回值的值类别。这样，无论是左值还是右值，process 函数都能保持原有的值类别，并正确处理。
在 main 函数中，我们分别调用 forward 函数来传递不同类型的参数。当我们传递一个左值 a 时，通过完美转发后调用了接受左值引用参数的 process 函数。当我们传递一个右值 20 时，调用了接受右值引用参数的 process 函数。当我们传递一个右值引用 std::move(a) 时，也调用了接受右值引用参数的 process 函数。
通过完美转发，我们可以实现将函数调用的参数准确地传递给其他函数，同时保持原始参数的值类别和常量性的完整性。这种机制在实现泛型函数、函数包装器和可变参数模板时非常有用。
