std::list<std::reference_wrapper<T>> 的概念受限的基于范围的 for 循环

Question

我有一些类 Foo 和一个 std::list<std::reference_wrapper<Foo>> 并希望使用基于范围的 for 循环迭代其元素：

#include <list>
#include <functional>
#include <iostream>


class Foo {
public:
    Foo(int a) : a(a) {}
    int a;
};

int main() {
    std::list<Foo> ls = {{1},{2},{3},{4}};
    std::list<std::reference_wrapper<Foo>> refs(ls.begin(), std::next(ls.begin(),2));
    
    for(auto &foo : refs) {
        std::cout << foo.get().a << std::endl;
    }

    for(Foo &foo : refs) {
        std::cout << foo.a << std::endl;
    }

    return 0;
}

注意auto 捕获时附加的get()，因为我们推断出std::reference_wrapper<Foo> 类型，而在第二种情况下foo 已经隐式转换为Foo& 类型，因为我们显式捕获了此类型。

我实际上是在寻找一种方法来捕捉 auto 但隐含地抛弃了 std::reference_wrapper 以便不必一直在 for 正文中打扰 get() 方法，所以我尝试引入一个合适的概念并抓住了这一点，即我尝试过

//this is not legal code

template<typename T>
concept LikeFoo = requires (T t) {
    { t.a };
};

int main() {
    std::list<Foo> ls = {{1},{2},{3},{4}};
    std::list<std::reference_wrapper<Foo>> refs(ls.begin(), std::next(ls.begin(),2));

    for(LikeFoo auto &foo : refs) {
        std::cout << foo.a << std::endl;
    }
    return 0;
}

并希望它会起作用。 clang 但是将foo 的类型推导出为std::reference_wrapper<Foo>，因此实际上下面的代码是正确的：

//this compiles with clang, but not with gcc

template<typename T>
concept LikeFoo = requires (T t) {
    { t.a };
};

int main() {
    std::list<Foo> ls = {{1},{2},{3},{4}};
    std::list<std::reference_wrapper<Foo>> refs(ls.begin(), std::next(ls.begin(),2));

    for(LikeFoo auto &foo : refs) {
        std::cout << foo.get().a << std::endl;
    }
    return 0;
}

然而，gcc 完全拒绝接受基于范围的 for 循环并抱怨 deduced initializer does not satisfy placeholder constraints，因为它试图检查 LikeFoo<std::reference_wrapper<Foo>>，这当然评估为 false，所以使用 gcc 甚至无法捕获 @ 987654342@ 概念受限。出现两个问题：

• 哪个编译器是正确的？ LikeFoo auto& foo : refs 应该有效吗？
• 有没有办法自动-catch（可能是概念受限的）foo : refs，这样就可以避免在for-loop 主体中写入get()？

您可以在Compiler explorer 找到此示例。

Answer 1

哪些编译器是正确的？ LikeFoo auto& foo : refs 应该有效吗？

没有。 refs 是reference_wrapper<Foo>& 的范围，因此foo 推导出对reference_wrapper<Foo> 的引用——它没有名为a 的成员。受约束的变量声明不会改变演绎的工作方式，它只是有效地表现得像一个额外的static_assert。

有没有办法自动捕获（可能是概念受限的）foo : refs，这样就可以避免在 for 循环体中写入 get()？

只需写refs？不可以。但是您可以编写一个范围适配器来将您的reference_wrapper<T> 范围转换为T& 的范围。标准库里已经有这样的东西了，transform：

for (auto &foo : refs | std::views::transform([](auto r) -> decltype(auto) { return r.get(); })) {

这是一口，所以我们可以让它自己命名适配器：

inline constexpr auto unwrap_ref = std::views::transform(
    []<typename T>(std::reference_wrapper<T> ref) -> T& { return ref; });

然后你可以写：

for (auto &foo : refs | unwrap_ref) { ... }
for (auto &foo : unwrap_ref(refs)) { ... }

不管怎样，foo 在这里推导出为Foo。

再做一点工作，您就可以编写一个范围适配器来解开reference_wrapper<T>，但保留任何其他引用类型。

Answer 2

这是一个在被取消引用时调用 get 的包装器的最低工作示例。

#include <list>
#include <functional>
#include <iostream>

template <typename T>
struct reference_wrapper_unpacker {
    struct iterator {
        typename T::iterator it;

        iterator& operator++() {
            it++;
            return *this;
        }

        iterator& operator--() {
            it--;
            return *this;
        }

        typename T::value_type::type& operator*() {
            return it->get();
        }

        bool operator!=(const iterator& other) const {
            return it != other.it;
        }
    };
    reference_wrapper_unpacker(T& container) : t(container) {}

    T& t;
    
    iterator begin() const {
        return {t.begin()};
    }

    iterator end() const {
        return {t.end()};
    }
};

class Foo {
public:
    Foo(int a) : a(a) {}
    int a;
};

int main() {
    std::list<Foo> ls = {{1},{2},{3},{4}};
    std::list<std::reference_wrapper<Foo>> refs(ls.begin(), std::next(ls.begin(),2));
    
    for(auto &foo : refs) {
        std::cout << foo.get().a << std::endl;
    }

    for(Foo &foo : refs) {
        std::cout << foo.a << std::endl;
    }

    for(auto &foo : reference_wrapper_unpacker{refs}) {
        std::cout << foo.a << std::endl;
    }

    return 0;
}

要使其在通用代码中可用，您需要 SFINAE 来检测容器是否确实具有 reference_wrapper，如果没有，则返回原始容器。

我将省略那部分，因为它不是原始问题的一部分。