在 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() 方法？

我知道你可以只拥有一个对象的向量，然后它就可以轻松工作。我的目标是能够拥有某种多态性而不必使用虚函数。

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

std::apply 或 std::invoke 有什么办法吗？

Answer 1

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's example 的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);

Answer 2

需要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);
}