在C 17/20中对元组进行迭代[重复]

Question

有人知道在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（）方法？

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

其想法是能够在元组中有支持相同方法的其他对象类型。如果该方法存在于每个对象中，那么代码将编译和执行，而不必使用基类、virtuals、vtable等。

使用std:：apply或std:：invoke是否有某种方法？

Answer 1

访问元组的每个成员需要一点std:：index_序列技巧。

#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);
}

Answer 2

使用std:：apply或std:：invoke是否有某种方法？

std:：apply使用折叠表达式满足需要：

std::tuple tplb{ Test{1} , Test{2} ,  Test{3} };

std::apply([](const auto&... tests){(tests.Go(), ...);}, tplb);

这里，我们为元组的每个类型值调用方法Go（）。

其想法是能够在元组中有支持相同方法的其他对象类型。如果该方法存在于每个对象中，那么代码将编译和执行，而不必使用基类、virtuals、vtable等。

所以上述方法是有效的。如果您想更进一步，并根据类型分配到不同的实现，您可以使用std:：visit示例中的重载类：

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);