高效检查包装在std::pair中的对象集合的属性

绝对有办法避免这种冗余复制！关键是让你的检查函数直接访问原容器里的foo对象，不需要把它们拷贝到新vector里。下面给你几个实用的高效方案，覆盖不同的C++版本和场景：

1. C++20 范围视图（最简洁零复制） #

如果你的项目已经用上C++20，标准库的**范围视图（ranges views）**是最优解——视图完全不会复制元素，只是提供一个“观察”原容器元素的轻量窗口，零开销。

首先，把你的检查函数改成支持任意输入范围的模板版本（如果原来的函数只接受std::vector<foo>，这是很小的改动）：

#include <ranges>

// 支持任意包含foo（或可转换为foo引用）的输入范围
template <std::ranges::input_range Range>
requires std::convertible_to<std::ranges::range_reference_t<Range>, const foo&>
bool check_collection(const Range& range) {
    // 保留你原来的集合属性检查逻辑，比如遍历元素：
    for (const auto& foo_obj : range) {
        // 对foo_obj执行检查操作...
    }
    return /* 检查结果 */;
}

调用时，用std::views::transform提取std::pair的first成员：

std::vector<std::pair<foo, /* 你的pair第二个类型 */>> pairs_container = /* 你的数据 */;

// 创建视图，直接引用原容器中的foo对象，无任何复制
auto foo_view = pairs_container | std::views::transform(
    [](const auto& pair_item) -> const foo& { return pair_item.first; }
);

// 传入视图进行检查
bool is_valid = check_collection(foo_view);

这个方案完全没有复制操作，所有对foo的访问都是直接引用原容器里的对象，性能拉满。

2. 自定义迭代器适配器（兼容C++11及以上） #

如果还在使用C11/C17，没法用C++20的范围，那可以写一个轻量的迭代器适配器，把原容器的迭代器包装一下，解引用时直接返回pair.first的引用。

先实现这个迭代器适配器：

template <typename BaseIter>
struct FooPairIterator {
    // 迭代器必备的类型别名（符合标准库迭代器要求）
    using value_type = foo;
    using reference = const foo&;
    using pointer = const foo*;
    using difference_type = typename BaseIter::difference_type;
    using iterator_category = typename BaseIter::iterator_category;

    BaseIter base_iter;

    // 构造函数：包装原迭代器
    explicit FooPairIterator(BaseIter iter) : base_iter(std::move(iter)) {}

    // 解引用返回pair的first成员引用
    reference operator*() const { return base_iter->first; }
    pointer operator->() const { return &base_iter->first; }

    // 迭代器递增操作
    FooPairIterator& operator++() {
        ++base_iter;
        return *this;
    }
    FooPairIterator operator++(int) {
        auto temp = *this;
        ++base_iter;
        return temp;
    }

    // 相等/不等判断
    bool operator==(const FooPairIterator& other) const {
        return base_iter == other.base_iter;
    }
    bool operator!=(const FooPairIterator& other) const {
        return base_iter != other.base_iter;
    }
};

然后给检查函数添加一个接受迭代器范围的重载（或者直接改成模板版本）：

// 接受任意迭代器范围的检查函数
template <typename Iter>
bool check_collection(Iter begin, Iter end) {
    for (Iter it = begin; it != end; ++it) {
        const foo& foo_obj = *it;
        // 你的检查逻辑...
    }
    return /* 检查结果 */;
}

调用时，用适配器包装原容器的迭代器：

std::vector<std::pair<foo, /* 你的pair第二个类型 */>> pairs_container = /* 你的数据 */;

bool is_valid = check_collection(
    FooPairIterator(pairs_container.begin()),
    FooPairIterator(pairs_container.end())
);

这个适配器同样不会复制任何foo对象，所有访问都是直接引用原容器中的元素，性能和C++20视图完全一致，只是需要手写一点迭代器代码。

3. 使用std::reference_wrapper（兼容C++11，适配固定接口） #

如果你的检查函数必须接受const std::vector<foo>&且无法修改接口，那可以用std::reference_wrapper创建一个存储引用的vector——这个vector的元素是对原foo对象的引用，不会复制foo本身，但需要检查函数能接受std::vector<std::reference_wrapper<const foo>>（或者你可以给检查函数加一个重载）：

#include <functional> // 包含std::reference_wrapper和std::cref

std::vector<std::pair<foo, /* 你的类型 */>> pairs_container = /* 你的数据 */;

// 创建存储foo引用的vector，无复制操作
std::vector<std::reference_wrapper<const foo>> foo_refs;
foo_refs.reserve(pairs_container.size()); // 提前分配空间，避免扩容开销
for (const auto& pair_item : pairs_container) {
    foo_refs.push_back(std::cref(pair_item.first));
}

// 如果检查函数有接受这个类型的重载，直接传入
bool is_valid = check_collection(foo_refs);

如果没办法给检查函数加重载，那最合理的选择还是修改检查函数的接口，让它支持迭代器或范围——这不仅能解决当前的复制问题，还能让函数更通用，适配更多容器类型。

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