向vector<reference_wrapper<string>>push_back后索引0字符串为空的问题

这个问题十有八九是悬垂引用搞的鬼！我之前也踩过类似的坑，给你拆解清楚原因，再给你对应的解决办法。

问题根源分析 #

reference_wrapper<string>本质就是个“安全版的指针”，它死死盯着原string对象的内存地址。如果原string的位置变了、被销毁了，这个引用就变成了悬垂引用——访问它就会出现未定义行为，比如返回空字符串、垃圾值，甚至直接崩程序。

结合你的场景（先存值到list再筛选到filtered），最可能触发的情况有这几种：

• list扩容导致元素地址变更：vector的特性是容量不够时会重新分配更大的内存，把旧元素挪过去再释放旧内存。这时候之前存在filtered里的引用还指着旧内存，自然读不到正确的值。
• 误存了临时对象的引用：如果筛选时不小心把临时string的引用塞进去（比如filtered.push_back(string("test"))），临时对象语句结束就销毁，引用直接失效。不过你说先存到list再筛选，这个概率低，但也得排查。
• 类对象拷贝/移动导致的悬垂：如果你的继承类对象被拷贝了，默认拷贝构造函数会直接复制filtered里的引用——这些引用指向的是原对象的list元素，原对象一销毁，新对象的filtered就全是无效引用了。

解决方案 #

针对不同场景，给你对应的解决办法：

1. 避免list扩容导致的引用失效 #

最直接的办法是在往list存元素前，先给它预留足够的容量，这样就不会触发扩容：

// 假设你知道要存100个元素，提前预留容量
list.reserve(100);
// 再逐个push_back元素
list.push_back("元素1");
list.push_back("元素2");
// ...

这样list的内存地址不会变，filtered里的引用就一直有效。

2. 确保只存list中有效元素的引用 #

筛选的时候，一定要直接引用list里的现有元素，绝对不能存临时对象的引用：

// 正确写法：取list中元素的引用存入filtered
for (auto& str : list) {
    if (str.size() > 5) { // 示例筛选条件：长度大于5的字符串
        filtered.push_back(str);
    }
}

// 错误写法！绝对不能这么做：
// filtered.push_back(string("临时字符串")); // 临时对象销毁后引用直接失效

3. 处理类对象的拷贝/移动问题 #

如果你的类需要被拷贝或移动，一定要自定义拷贝/移动构造函数和赋值运算符，确保filtered里的引用指向当前对象的list元素：

class YourDerivedClass : public YourBaseClass {
public:
    vector<string> list;
    vector<reference_wrapper<string>> filtered;

    // 拷贝构造函数：复制list后重新筛选
    YourDerivedClass(const YourDerivedClass& other) : list(other.list) {
        // 复刻原对象的筛选逻辑
        for (auto& str : list) {
            if (符合你的筛选条件) {
                filtered.push_back(str);
            }
        }
    }

    // 移动构造函数：接管list后重新筛选
    YourDerivedClass(YourDerivedClass&& other) noexcept : list(std::move(other.list)) {
        for (auto& str : list) {
            if (符合你的筛选条件) {
                filtered.push_back(str);
            }
        }
        // 清空原对象的filtered，避免它的引用悬垂
        other.filtered.clear();
    }

    // 拷贝赋值运算符
    YourDerivedClass& operator=(const YourDerivedClass& other) {
        if (this != &other) {
            list = other.list;
            filtered.clear();
            for (auto& str : list) {
                if (符合你的筛选条件) {
                    filtered.push_back(str);
                }
            }
        }
        return *this;
    }

    // 移动赋值运算符
    YourDerivedClass& operator=(YourDerivedClass&& other) noexcept {
        if (this != &other) {
            list = std::move(other.list);
            filtered.clear();
            for (auto& str : list) {
                if (符合你的筛选条件) {
                    filtered.push_back(str);
                }
            }
            other.filtered.clear();
        }
        return *this;
    }
};

4. 备选方案：改用指针（如果引用不好控制） #

如果觉得reference_wrapper太容易踩坑，也可以改用vector<string*>，不过要注意确保指针指向的string一直存在：

vector<string*> filtered;
// 筛选时存list元素的地址
for (auto& str : list) {
    if (符合筛选条件) {
        filtered.push_back(&str);
    }
}

这种方式和reference_wrapper本质一样，只是写法不同，同样要注意避免悬垂指针。

快速验证方法 #

你可以打印list元素和filtered引用的地址，看看是否一致，就能快速定位问题：

#include <iostream>
// ...其他头文件

// 存完元素到list后打印地址
for (size_t i = 0; i < list.size(); ++i) {
    std::cout << "list[" << i << "] 地址: " << &list[i] << std::endl;
}
// 存完filtered后打印引用指向的地址
for (size_t i = 0; i < filtered.size(); ++i) {
    std::cout << "filtered[" << i << "] 指向的地址: " << &filtered[i].get() << std::endl;
}

如果地址不一样，那肯定是list扩容导致的，用reserve就能解决。

内容的提问来源于stack exchange，提问作者T.N.