在 C++17/20 中迭代元组

Iterating over tuple in C++17/20

本文关键字：迭代 元组 C++17      更新时间：2023-10-16

有谁知道在 C++17/20 中迭代元组的好、干净的方法？ 假设我们有这样一段代码：

class Test
{
    public:
        Test( int x ) : x_(x) {};
        void Go() const { std::cout << "Hi!" << x_ << "n" ; }
        int x_;
};
int main()
{
    std::tuple tplb{ Test{1} , Test{2} ,  Test{3} };
}

我们如何遍历元组并使用最新的 17/20 功能在每个元组上调用 Go() 方法？

我知道你可以有一个对象的向量，然后它很容易工作。 我的目标是能够在不必使用虚函数的情况下实现某种多态性。

这个想法是能够在元组中拥有支持相同方法的其他对象类型。 如果该方法存在于每个对象中，则代码将编译和执行，而无需使用基类、虚拟、vtable 等。

有没有办法std::apply或std::invoke？

有没有办法std::apply或std::invoke？

std::apply确实需要折叠表达：

std::tuple tplb{ Test{1} , Test{2} ,  Test{3} };
std::apply([](const auto&... tests){(tests.Go(), ...);}, tplb);

在这里，我们对tuple的每个类型值调用方法 Go() 。

这个想法是能够在元组中拥有支持相同方法的其他对象类型。如果该方法存在于每个对象中，则代码将编译和执行，而无需使用基类、虚拟、vtable 等。

所以上面的方法有效。如果你更进一步，根据类型调度到不同的实现，你可以使用 std：：visit 示例中overloaded类：

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
auto f = overloaded {
        [](const Test& test) { test.Go(); },
        [](double d) { std::cout << d << ' '; },
        [](const std::string& s) { std::cout << s << ' '; },
    };
std::apply([&](const auto&... e){ (f(e), ...);}, my_tuple);

> 需要一些std::index_sequence技巧来访问元组的每个成员。

#include <iostream>
#include <tuple>
#include <utility>
class Test
{
    public:
        Test( int x ) : x_(x) {}; 
        void Go() const { std::cout << "Hi!" << x_ << "n" ; } 
        int x_; 
};

template<typename F, typename T, std::size_t... Index>
void doStuffIndex(F&& action, T const& tup, std::index_sequence<Index...> const&)
{
    bool ignore[] = {((std::get<Index>(tup).*action)(), true)...};
}
template<typename F, typename... Obj>
void doStuff(F&& action, std::tuple<Obj...> const& tup)
{
    doStuffIndex(action, tup, std::make_index_sequence<sizeof...(Obj)>());
}
int main()
{
    std::tuple<Test, Test, Test> tplb{ Test{1} , Test{2} ,  Test{3} };
    doStuff(&Test::Go, tplb);
}
相关文章：