如何用引用遍历存储 std::unique_ptr 的 vector 和 map?
把循环变量声明为引用即可:使用 for (auto& e : kv),或者使用结构化绑定 for (auto& [key, value] : kv)。这两种写法都直接访问容器中的元素,既不复制 std::unique_ptr,也不转移它的所有权。
为什么 for (auto e : kv) 会复制元素?
std::map<K, V> 的元素类型是:
std::pair<const K, V>
对于普通的 std::map,范围 for 每次迭代都会用迭代器指向的元素初始化循环变量。下面两种声明的区别在于是否保留引用:
// 每次迭代复制一个 pair。
for (auto e : kv) {
// e 是独立对象。
}
// 每次迭代引用 map 中已有的 pair。
for (auto& e : kv) {
// e 是容器元素的别名。
}
当 V 是 std::unique_ptr<T> 时,第一种写法需要复制包含 std::unique_ptr<T> 的 pair。由于 std::unique_ptr 不允许复制,这段循环无法编译。
e.first 和 e.second 这样的成员访问本身不会创建副本。原代码中有两层可能发生复制的位置:
for (auto e : kv) { // 复制整个元素。
auto k = e.first; // 再复制键。
auto v = e.second; // 再复制值。
}
仅修改循环声明还不够。如果循环体里也需要引用值,应继续使用 auto&。
如何通过 first 和 second 访问原对象?
对于可修改的 map,可以这样写:
for (auto& e : kv) {
const auto& k = e.first;
auto& v = e.second;
// k 引用原键,v 引用原值。
}
这里 e 引用整个 pair。容器元素不必是“成员都是引用的 pair”;通过 e 访问成员时,访问的就是原对象的成员。
map 的键是 const K,即使用 auto& 遍历,也不能直接修改 e.first。值 e.second 则可以通过引用修改。
在 auto& e 这样的声明中,& 用来声明引用;在表达式 &e 中,& 是取地址运算符。
如何遍历包含 std::unique_ptr 的 map 和 vector?
下面的 C++20 示例展示了这两种容器的写法:
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <vector>
int main() {
std::map<int, std::unique_ptr<std::string>> kv;
kv.emplace(1, std::make_unique<std::string>("one"));
// key 绑定到键,ptr 绑定到容器中的 unique_ptr。
for (auto& [key, ptr] : kv) {
if (ptr) {
*ptr += "!";
std::cout << key << ": " << *ptr << '\n';
}
}
std::vector<std::unique_ptr<std::string>> values;
values.push_back(std::make_unique<std::string>("two"));
// ptr 引用 vector 中的 unique_ptr。
for (auto& ptr : values) {
if (ptr) {
*ptr += "!";
std::cout << *ptr << '\n';
}
}
}
结构化绑定中的 & 同样不能省略:
for (auto& [key, ptr] : kv) {
// 引用容器元素,没有复制。
}
// 对包含 unique_ptr 的 map,这种写法会因尝试复制而编译失败:
// for (auto [key, ptr] : kv) { }
如果只需读取,可以使用 const auto&:
for (const auto& [key, ptr] : kv) {
if (ptr) {
std::cout << key << ": " << *ptr << '\n';
}
}
这里的 const 限制的是 std::unique_ptr 对象,不能通过 ptr 调用 reset() 或转移其所有权。不过,const std::unique_ptr<T> 仍允许修改它指向的非 const 对象。如果需要限制对被指向对象的修改,可以使用 std::unique_ptr<const T>,或通过 const T& 访问该对象。
如何创建复制键、引用值的 pair?
如果确实需要一个独立的 pair,可以显式将第二个成员的类型声明为引用。下面以字符串为值,展示这种关系:
#include <map>
#include <string>
#include <utility>
std::map<int, std::string> kv;
kv.emplace(1, "one");
for (auto& e : kv) {
std::pair<int, std::string&> view{e.first, e.second};
view.first = 2; // 修改的是复制出来的键,kv 中的键仍为 1。
view.second = "ONE"; // 修改的是 kv 中的字符串。
}
一般形式是:
std::pair<K, V&> view{e.first, e.second};
这要求 K 可以从 e.first 复制构造。当 V 是 std::unique_ptr<T> 时,第二个成员是对该智能指针的引用,不会复制智能指针。
如果也不想复制键,可以声明:
std::pair<const K&, V&> view{e.first, e.second};
这些 pair 都不拥有它们引用的对象。对应的容器元素被删除或容器被销毁后,引用就会失效。如果只是为了遍历,直接使用 auto& e 或 auto& [key, value] 更简单。
原测试程序应该改哪里?
把最后的循环改成下面这样,就能让 e.second 和 e4 都访问 Amap 中的对象:
for (auto& e : Amap) {
A& e4 = e.second;
e4.where(&e4, "e4", "for (auto& e : Amap) A& e4 = e.second;");
}
原来的 A& e4 = e.second 只是给已经复制出来的成员建立引用,无法撤销循环变量初始化时发生的复制。Amap[e.first] 会按键重新访问容器,所以原测试中的 e2 能引用容器内的对象。在循环中直接使用 e.second 可以省去这次查找。
阅读日志时还要注意:测试中的 count 在复制构造和移动构造时都会增加,因此它不是单纯的复制次数。应结合实际调用的构造函数判断,不能仅凭地址变化认定发生了复制。
正常的引用遍历不需要 std::move。只有确实要取走所有权时,才使用 auto owned = std::move(ptr);;执行后,容器中的这个 std::unique_ptr 会变为空指针。访问 *ptr 前也应确认它非空。
备注:内容仅供参考。
