有什么方法可以从不同对象的元组（但派生自相同的基 class）构建指针数组？

Question

大家早上好！

阅读堆栈溢出很长时间了，但这是我第一次post。

出于某些原因，我想做这样的事情：

class Base{
   ...
}

class A : public Base{
   ...
}

class B : public Base{
   ...
}

std::tuple<A, B> myTuple{A{}, B{}};

std::array<Base*, 2> myArray{...};

简而言之 - 我想在一个元组对象中存储几十个对象，但在某些时候我需要一个包含指向所有这些元素的指针的容器。它们都继承自同一个 class，这是我的界面 class。

而且我不知道如何从 myTuple 中提取元素，获取指向其所有元素的指针（与定义的顺序完全相同）并将它们分配给 myArray。

我在不同的问题中看到了一些解决方案，但其中 none 适合我的具体情况。我刚学模板，所以这对我来说有点难。

代码取自：

template <class Tuple>
struct make_array;

template <class V, template <V N> class C, V... Ns>
struct make_array<std::tuple<C<Ns>... >> {
    static constexpr Tf::TaskFlow<3>::TaskArray value{&Ns... };
};

template <class Tuple>
constexpr auto make_array_v = make_array<Tuple>::value;

但也许它可以根据我的需要进行修改？

Answer 1

可以使用各种编译时编程技术创建指向元组成员的指针数组。下面是一个实现。可能有一种不那么冗长的方法，但我不是这类东西的专家：

#include <iostream>
#include <string>
#include <array>
#include <tuple>

class Base {
public:
    virtual std::string foo() = 0;
};

class A : public Base {
public:
    std::string foo() override {
        return "A";
    }
};

class B : public Base {
public:
    std::string foo() override {
        return "B";
    }
};

template<size_t I, typename... Ts>
void tuple_to_base_ptr_array_aux(std::tuple<Ts...>& tup,
        std::array<Base*, sizeof...(Ts)>& ary) {
    if constexpr (I < sizeof...(Ts)) {
        ary[I] = static_cast<Base*>( &(std::get<I>(tup)) );
        tuple_to_base_ptr_array_aux<I + 1>(tup, ary);
    }
}

template<typename... Ts>
std::array<Base*, sizeof...(Ts)> tuple_to_base_ptr_array( std::tuple<Ts...>& tup) {
    std::array<Base*, sizeof...(Ts)> ary;
    tuple_to_base_ptr_array_aux<0>(tup, ary);
    return ary;
}

int main() {
    std::tuple<A, B, A, A, B, A> foo;
    auto ary = tuple_to_base_ptr_array(foo);
    for (auto* ptr : ary) {
        std::cout << ptr->foo();
    }
    std::cout << "\n";
    return 0;
}

有什么方法可以从不同对象的元组（但派生自相同的基 class）构建指针数组？

Any way to build an array of pointers from a tuple of different objects (but derived from the same base class)?

c++

arrays

pointers

tuples

metaprogramming