21、移动语义与模板：模板中的移动语义、decltype(auto) 与移动、模板元编程中的移动优化

模板遇上移动语义，这事儿就变得有意思了。说实话，我早年写模板的时候，移动语义还没进标准呢。那时候写个泛型函数，传参全靠 const 引用，返回值全靠拷贝。后来 C++11 一出来，我第一反应是——模板里怎么用移动？

嗯，这章我们就来聊聊这个。模板里的移动语义，说白了就是「我不知道类型是什么，但我希望它该移动时就移动」。这听起来简单，做起来坑不少。

模板中的转发问题：我该用 T&& 还是 const T&？

先看个基础场景。你写了个工厂函数，想完美转发参数给构造函数：

template<typename T, typename Arg>
T create(Arg&& arg) {
    return T(std::forward<Arg>(arg));
}

这里 Arg&& 不是右值引用，而是转发引用（也叫万能引用）。它既能绑定左值，也能绑定右值。配合 std::forward，就能保持参数的值类别不变。

我在项目中遇到过一个问题：有人把 T&& 和 Arg&& 搞混了。前者是右值引用，后者是转发引用。区别在哪？看模板参数推导：

template<typename T>
void func(T&& t);  // 转发引用

template<typename T>
void func(std::vector<T>&& t);  // 右值引用，不是转发引用

判断标准很简单：如果 T&& 中的 T 是模板参数自己推导出来的，那就是转发引用。否则就是右值引用。

decltype(auto) 与移动：返回值也能完美转发

C++14 引入了 decltype(auto)，这东西在移动语义里特别好用。你想想看，有时候我们想返回一个表达式的结果，但又不想多写一遍类型：

template<typename Container, typename Index>
decltype(auto) getElement(Container&& c, Index i) {
    return std::forward<Container>(c)[i];
}

这里 decltype(auto) 会保留表达式的引用性质。如果 c 是左值，返回左值引用；如果是右值，返回右值引用。说白了，它让返回值也能完美转发。

我曾经踩过一个坑：用 auto 代替 decltype(auto) 做返回值：

template<typename Container, typename Index>
auto getElement(Container&& c, Index i) {
    return std::forward<Container>(c)[i];  // 总是按值返回！
}

这样写，auto 会剥掉引用，每次都拷贝一份。对于大容器来说，性能直接崩了。

模板元编程中的移动优化：编译期就决定怎么传

模板元编程（TMP）和移动语义结合，能玩出不少花样。比如，我们可以在编译期判断一个类型是否支持移动：

template<typename T>
struct is_move_assignable {
private:
    template<typename U>
    static auto check(int) -> decltype(
        std::declval<U>() = std::declval<U&&>(), 
        std::true_type{}
    );
    
    template<typename>
    static std::false_type check(...);
    
public:
    static constexpr bool value = 
        decltype(check<T>(0))::value;
};

这个技巧叫 SFINAE（替换失败不是错误）。如果 T 不支持移动赋值，check(int) 的返回类型推导会失败，编译器就选 check(...) 版本，返回 false。

我在实际项目中用过类似的技术：写一个通用的资源管理类，根据类型是否支持移动，选择不同的内部实现：

template<typename T>
class ResourceHolder {
    // 如果 T 可移动，用 unique_ptr 管理
    // 如果 T 不可移动，用 shared_ptr 管理
    using Storage = std::conditional_t<
        std::is_move_constructible_v<T>,
        std::unique_ptr<T>,
        std::shared_ptr<T>
    >;
};

嗯，这里要注意：std::conditional_t 是 C++14 的语法，C++11 用 typename std::conditional<...>::type。

移动优化在模板中的常见模式

我总结了几种常用的模式，直接上代码：

模式	代码	说明
转发引用 + forward	template<typename T> void f(T&& t) { g(std::forward<T>(t)); }	保持参数值类别
decltype(auto) 返回值	decltype(auto) f() { return expr; }	保留引用性质
enable_if 控制移动	template<typename T, enable_if_t<is_move_constructible_v<T>, int> = 0>	只对可移动类型启用
移动迭代器	std::make_move_iterator(begin)	将迭代器解引用转为右值

移动迭代器这个，我单独说两句。它可以把普通迭代器变成移动迭代器，解引用时返回右值引用。常用于从容器中搬移元素：

std::vector<std::string> src = {"a", "b", "c"};
std::vector<std::string> dst(
    std::make_move_iterator(src.begin()),
    std::make_move_iterator(src.end())
);
// src 中的字符串被移走了，现在都是空字符串

一个完整的例子：泛型移动容器

最后，我写个综合例子，把上面这些知识点串起来：

#include <type_traits>
#include <utility>

template<typename T>
class MoveOptimizedWrapper {
    T value;
    
public:
    // 转发引用构造函数
    template<typename U, 
             typename = std::enable_if_t<
                 std::is_constructible_v<T, U&&>
             >>
    explicit MoveOptimizedWrapper(U&& u) 
        : value(std::forward<U>(u)) {}
    
    // decltype(auto) 访问器
    decltype(auto) get() & { 
        return value; 
    }
    
    decltype(auto) get() && { 
        return std::move(value); 
    }
    
    // 编译期判断是否可移动
    static constexpr bool is_movable = 
        std::is_move_constructible_v<T>;
};

这个类展示了几个关键点：

• 构造函数用转发引用 + SFINAE 控制类型
• get() 根据对象是左值还是右值，决定返回引用还是移动
• 编译期常量 is_movable 让调用方可以判断

说实话，这些技巧我用了好几年才真正吃透。刚开始写模板时，总觉得「反正都是泛型，随便传呗」。后来被性能问题教育了几次，才明白移动语义在模板里的重要性。你想想看，一个模板函数可能被上千个地方调用，如果每个调用都多一次拷贝，那性能损失就大了。

嗯，这章就到这里。记住一句话：模板里写移动，不是为了炫技，是为了让用户无感地获得最佳性能。