如何使用std::transform操作存储std::reference_wrapper的容器？

这个问题的核心在于std::reference_wrapper本质是引用的包装器，它只能绑定到左值（有持久内存地址的对象），而且构造/赋值有严格的类型匹配要求，你遇到的编译错误正是因为代码试图用临时值（或不匹配const属性的引用）构造std::reference_wrapper<float>，而它的移动构造函数被显式删除了（毕竟引用不能被移动）。

错误原因拆解 #

当你往std::vector<std::reference_wrapper<float>>写入时，默认的std::transform逻辑可能在尝试类似这样的操作：

// 伪代码，模拟错误场景
std::reference_wrapper<float> dest_element = *src_element; // src_element解引用后是const float&

但std::reference_wrapper<float>需要绑定到非const的float左值，而源容器里的元素是std::reference_wrapper<const float>，解引用后是const float&——const引用无法隐式转换为非const引用，同时编译器也不能用临时float值构造reference_wrapper<float>（因为它的移动构造被删除），这就触发了你看到的错误。

正确的使用方式 #

要让std::transform和std::reference_wrapper容器配合工作，你需要明确：reference_wrapper容器存储的是对已有对象的引用，不是值。所以目标容器里的每个reference_wrapper<float>必须绑定到一个已经存在的、非const的float对象。

场景1：源引用的目标本身是非const的（可修改）

如果你的源std::reference_wrapper<const float>实际上引用的是一个非const的float对象（只是被const引用包装），你可以通过const_cast获取非const引用，再构造目标的reference_wrapper：

#include <vector>
#include <algorithm>
#include <functional>

int main() {
    // 原始可修改的float数组
    std::vector<float> values = {1.0f, 2.0f, 3.0f};
    // 源容器：const引用包装
    std::vector<std::reference_wrapper<const float>> const_refs(values.begin(), values.end());
    // 目标容器：非const引用包装
    std::vector<std::reference_wrapper<float>> non_const_refs;
    non_const_refs.reserve(const_refs.size());

    std::transform(const_refs.begin(), const_refs.end(),
                   std::back_inserter(non_const_refs),
                   [](const std::reference_wrapper<const float>& ref) {
                       // 务必确保原始对象是非const的，否则const_cast会导致未定义行为
                       return std::reference_wrapper<float>(const_cast<float&>(ref.get()));
                   });

    // 测试修改：通过目标引用修改原始值
    non_const_refs[0].get() = 10.0f;
    // values[0]现在是10.0f
    return 0;
}

⚠️ 注意：只有当你确定原始对象本身是非const的时候，才能使用const_cast，否则会触发未定义行为。

场景2：目标引用绑定到新的float对象

如果你想让目标容器的reference_wrapper<float>绑定到新的float值（而不是源引用的对象），那你需要先创建这些新的float对象（比如另一个std::vector<float>），然后让reference_wrapper引用它们：

#include <vector>
#include <algorithm>
#include <functional>

int main() {
    std::vector<std::reference_wrapper<const float>> const_refs = {/* 假设这里有已有的const float引用 */};
    // 先创建存储实际值的容器
    std::vector<float> target_values(const_refs.size());
    // 目标容器：引用target_values里的元素
    std::vector<std::reference_wrapper<float>> non_const_refs;
    non_const_refs.reserve(target_values.size());
    for (auto& val : target_values) {
        non_const_refs.emplace_back(val);
    }

    // 用transform把源的值复制到目标引用指向的对象
    std::transform(const_refs.begin(), const_refs.end(),
                   non_const_refs.begin(),
                   [](const std::reference_wrapper<const float>& ref) {
                       return ref.get(); // 返回const float&，赋值给目标引用指向的float
                   });

    return 0;
}

这里的关键是：先有实际存储值的对象，再让reference_wrapper绑定到它们，而不是试图让reference_wrapper直接存储值。

关键总结 #

• std::reference_wrapper<T>不能绑定到临时值，必须绑定到已存在的左值对象。
• 类型匹配必须严格：reference_wrapper<const T>不能隐式转换为reference_wrapper<T>，需要显式处理（且确保安全）。
• 用std::transform操作reference_wrapper容器时，要明确你是在操作引用指向的对象，还是在创建新的引用绑定关系。

内容的提问来源于stack exchange，提问作者Gladaed