C++11完美转发的作用和用法

完美转发的作用，是在"包装函数"里把参数原样传给下一级函数，不改变它原本的左值/右值属性，也尽量不引入多余拷贝。

最典型的场景是：你写了一个中间层函数，它不真正处理参数，只是把参数继续交给别的构造函数、成员函数或工厂函数。如果这个中间层写得不对，就会把右值变成左值，导致多一次拷贝，甚至调用错重载。

作用

1. 保留实参的值类别。

   左值传进去，下面继续当左值用；右值传进去，下面继续当右值用。

2. 避免不必要的拷贝或移动。

   这就是很多标准库接口高效的原因，比如 emplace_back、make_unique、make_shared。

3. 避免写大量重载。

   不用分别写左值版、右值版、const 版，模板可以统一处理。

基本用法

完美转发通常是这两个东西配套出现：

1. 转发引用

   也就是模板里的 T&&

2. std::forward<T>(arg)

   负责按 T 推导出来的类型，把参数恢复成原本该有的左值或右值

最常见写法：

template <class T>
void wrapper(T&& arg) {
    target(std::forward<T>(arg));
}

这里的关键是：

如果调用 wrapper(x)，x 是左值，那么 T 会推导成 T = int&，最后 std::forward<T>(arg) 还是左值。

如果调用 wrapper(10)，10 是右值，那么 T 会推导成 T = int，最后 std::forward<T>(arg) 是右值。

为什么不能直接传

看这个例子：

#include <iostream>
#include <utility>

void foo(int& x) {
    std::cout << "lvalue\n";
}

void foo(int&& x) {
    std::cout << "rvalue\n";
}

template <class T>
void bad_wrapper(T&& arg) {
    foo(arg);
}

template <class T>
void good_wrapper(T&& arg) {
    foo(std::forward<T>(arg));
}

int main() {
    int x = 10;

    bad_wrapper(x);   // lvalue
    bad_wrapper(20);  // 也是 lvalue

    good_wrapper(x);  // lvalue
    good_wrapper(20); // rvalue
}

为什么 bad_wrapper(20) 还是左值？

因为函数参数 arg 本身有名字，只要有名字，它就是左值表达式。哪怕它的类型写成 T&&，在函数体里用 arg 时，它依然是左值。

所以必须用 std::forward<T>(arg) 把它"按原始类别转回去"。

和 std::move 的区别

std::move 的意思是：无条件把对象当右值。

std::forward 的意思是：如果调用者当初传来的是右值，就转成右值；如果传来的是左值，就保持左值。

所以在转发场景里：

1. 用 std::forward
2. 不要用 std::move

因为一旦你在包装函数里对所有参数都 std::move，就会错误地把左值也偷走。

例子：

template <class T>
void wrapper(T&& arg) {
    target(std::move(arg));   // 不适合完美转发
}

如果调用者传的是左值，这里也会被强行当成右值，语义就错了。

典型应用

1. 包装已有接口

   template <class T>

   void log_and_call(T&& arg) {

   // 先记录日志

   target(std::forward<T>(arg));

   }

2. 工厂函数

   template <class T, class... Args>

   T* create(Args&&... args) {

   return new T(std::forward<Args>(args)...);

   }

3. 容器原地构造

   标准库里的 emplace_back 本质就是把参数完美转发给元素构造函数。

什么是转发引用

不是所有 T&& 都能完美转发。只有"发生模板类型推导"的这种 T&& 才叫转发引用。

比如：

template <class T>
void f(T&& x);

这里 x 是转发引用。

但下面不是：

void f(int&& x);

这只是普通右值引用，不具备"左值传进来也能匹配"的特性。

还有一个常见例子：

auto&& x = expr;

这里也可能是转发引用语义。

一个完整例子

这个例子更接近实际工程：

#include <iostream>
#include <string>
#include <utility>

struct Person {
    Person(const std::string& name) {
        std::cout << "copy from lvalue\n";
    }

    Person(std::string&& name) {
        std::cout << "move from rvalue\n";
    }
};

template <class... Args>
Person make_person(Args&&... args) {
    return Person(std::forward<Args>(args)...);
}

int main() {
    std::string name = "Alice";

    Person p1 = make_person(name);                 // lvalue
    Person p2 = make_person(std::string("Bob"));  // rvalue
}

这里 make_person 不需要知道调用者给的是左值还是右值，但它能把语义正确传给 Person 的构造函数。

常见误区

1. 以为 T&& 一定是右值引用。

   错。模板推导场景下，T&& 往往是转发引用。

2. 以为函数里 arg 是右值。

   错。只要 arg 有名字，它在表达式里就是左值。

3. 在转发函数里用 std::move。

   这会破坏左值实参。

4. 转发多次同一个对象。

   如果第一次已经把右值往下转走了，再继续用它，状态可能已经被移动过。

5. 花括号初始化不能总是顺利转发。

   比如 initializer_list 相关场景，经常需要单独处理。

一句话记忆

完美转发就是：

1. 用 T&& 接
2. 用 std::forward<T>(arg) 传

可以把这 3 个概念看成一条链：

值类别（左值 / 右值）
        ↓
右值引用（T&&）提供语言层能力
        ↓
移动语义：把"可转移资源"从一个对象挪到另一个对象
        ↓
完美转发：在中间层把参数的左值/右值属性原样传下去

核心区别是：

1. 右值引用是语言机制
2. 移动语义是使用这个机制实现的"资源转移"语义
3. 完美转发是另一个用法，它不是"转移资源"，而是"保留实参原本身份并继续传递"

可以再压成一张更直观的图：

左值 x ---------------------------> 普通使用
  |                                   |
  | std::move(x)                      | 直接传参
  v                                   v
将 x 强制看成右值                参数进入包装函数
  |                                   |
  v                                   |
触发移动构造 / 移动赋值               | T&& + std::forward<T>(arg)
  |                                   v
  └-------- 这叫移动语义 --------> 原样转发给下一级
                                  |
                                  └---- 这叫完美转发

先分别看它们各自"解决什么问题"。

右值引用

右值引用就是 T&& 这种类型形式。它的主要价值是：允许你区分"这个对象还能继续稳定使用"还是"这个对象马上就要被销毁，可以安全偷资源"。

典型例子：

std::string a = "hello";
std::string b = std::move(a);

这里不是 std::move 真把东西搬走了，而是它把 a 转成了一个右值，让后续构造函数有机会调用移动构造，把内部缓冲区挪给 b。

所以：

1. 右值引用是"能移动"的基础
2. std::move 只是一个强制类型转换
3. 真正发生资源转移的是移动构造/移动赋值函数

移动语义

移动语义解决的是性能问题和资源所有权转移问题。

比如 vector、string、智能指针这类对象内部通常有堆内存、句柄、指针。复制它们可能很贵，而移动只需要"偷走指针，再把源对象置为空状态"。

所以移动语义更像是在说：

"这个对象你别拷贝了，直接把里面资源交出去。"

典型使用场景：

1. 返回临时对象
2. 容器扩容搬迁元素
3. 明确表示"这个参数我后面不再用了"

这种场景下你通常写的是 std::move，不是 std::forward。

完美转发

完美转发解决的不是"偷资源"，而是"中间层不要破坏参数语义"。

看这个场景：

template <class T>
void wrapper(T&& arg) {
    target(std::forward<T>(arg));
}

wrapper 不真正消费参数，它只是个中转站。此时它最应该做的事不是决定"要不要 move"，而是把调用者的原始意图保留下来：

1. 调用者传左值，就按左值传下去
2. 调用者传右值，就按右值传下去

这就是完美转发。

所以一句话区分：

1. std::move：我主动声明"这个对象现在可以被拿走资源"
2. std::forward：我不替调用者做决定，只把它原样转交下去

三者的关系

最容易混的地方在这：

1. 完美转发底层也依赖 T&&
2. 但这里的 T&& 不是普通右值引用，而是转发引用
3. 转发引用配合 std::forward<T>，实现"保留值类别"
4. 普通右值引用更多用于"接收可被移动的对象"

也就是说：

普通右值引用
用途：消费对象、实现移动语义

转发引用
用途：保留对象原始值类别、实现完美转发

虽然都长得像 T&&，但语义不同。

什么时候用谁

这是最实用的判断标准。

如果你写的是"最终使用者/消费者"，比如：

1. 移动构造函数
2. 移动赋值函数
3. 存储并接管参数资源的函数

通常考虑 std::move。

如果你写的是"中间层/包装层/工厂函数"，比如：

1. emplace_back
2. make_unique
3. 日志包装器
4. 调用转发器

通常要用 std::forward。

可以直接记这个判断法：

1. 我要"消费"它，用 std::move
2. 我要"转交"它，用 std::forward

一个对比例子

看下面这段最清楚：

#include <iostream>
#include <utility>

void target(int& )  { std::cout << "lvalue\n"; }
void target(int&&)  { std::cout << "rvalue\n"; }

template <class T>
void forward_wrapper(T&& arg) {
    target(std::forward<T>(arg));
}

template <class T>
void move_wrapper(T&& arg) {
    target(std::move(arg));
}

int main() {
    int x = 10;

    forward_wrapper(x);   // lvalue
    forward_wrapper(20);  // rvalue

    move_wrapper(x);      // rvalue
    move_wrapper(20);     // rvalue
}

区别就在这里：

1. forward_wrapper 保留调用者原意
2. move_wrapper 不管三七二十一都当右值处理

所以 move_wrapper(x) 是危险的，因为调用者传来的是左值，但你擅自把它当成"可被拿走资源"的对象了。

一句话总结构图

你可以这样背：

右值引用：语言工具
移动语义：拿这个工具做"资源转移"
完美转发：拿这个工具做"语义保留后继续传递"

再压缩一点：

std::move = 主动转成右值，准备被移动
std::forward = 按调用者原本类型转发