如何存储指针的矢量，包含不同的类型

假设:

• 你的问题是一个XY问题，你只认为存储指针到不同类型的向量可能是一个解决方案而不是解决方案，和
• 你知道编译时的组件类型列表(而不是允许运行时注册)，

，这是相对容易实现的方式，通过元组和一些机制来迭代它。

首先，在给定组件类型列表的情况下，我们需要一个元函数来生成正确的元组类型:

namespace detail {
    template<std::size_t N, typename... Components>
    std::tuple<std::array<Components, N>...>
    makeComponentPool(std::tuple<Components...>) noexcept;
} // namespace detail
template<std::size_t N, typename ComponentTup>
using ComponentPool = decltype(detail::makeComponentPool<N>(std::declval<ComponentTup>()));
// example:
static_assert(std::is_same<
    ComponentPool<10, std::tuple<AIComponent, PhysicsComponent, RenderComponent>>,
    std::tuple<
        std::array<AIComponent, 10>,
        std::array<PhysicsComponent, 10>,
        std::array<RenderComponent, 10>
    >
>::value);

则需要某种遍历元组的方法;boost::fusion::for_each在这里工作得很好，或者我们可以滚动我们自己的:

namespace detail {
    template<typename TupT, typename FunT, std::size_t... Is>
    void for_each(TupT&& tup, FunT&& f, std::index_sequence<Is...>) {
        using expand = int[];
        (void)expand{0, (f(std::get<Is>(std::forward<TupT>(tup))), void(), 0)...};
    }
} // namespace detail
template<
    typename TupT, typename FunT,
    std::size_t TupSize = std::tuple_size<std::decay_t<TupT>>::value
>
void for_each(TupT&& tup, FunT&& f) {
    detail::for_each(
        std::forward<TupT>(tup), std::forward<FunT>(f),
        std::make_index_sequence<TupSize>{}
    );
}

现在我们需要做一个决定:每个组件类型应该有相同的公共访问点吗?问题中既有update()也有render();但是，如果我们可以给这些都赋予相同的名称(例如process())，那么事情就非常简单了:

struct AIComponent      { void process() { } };
struct PhysicsComponent { void process() { } };
struct RenderComponent  { void process() { } };
class Game {
    using ComponentTypes = std::tuple<AIComponent, PhysicsComponent, RenderComponent>;
    static constexpr std::size_t MAX_NUM = 3;
    ComponentPool<MAX_NUM, ComponentTypes> componentPool;
    std::atomic_bool gameOver{false};
public:
    void runGame() {
        while (!gameOver) {
            for_each(componentPool, [](auto& components) {
                for (auto& component : components) {
                    component.process();
                }
            });
        }
    }
    void endGame() { gameOver = true; }
};

在线演示
<子>(注意。在演示中，给process()一个参数只是为了说明，而不是因为任何实现需求。)

现在你只需要管理MAX_NUM和ComponentTypes，其他的一切都到位了。

然而，如果你想允许不同组件类型的不同接入点(例如update()用于AIComponent和PhysicsComponent，但render()用于RenderComponent，如问题所示)，那么我们显然还有一些工作要做。一种方法是为调用访问点添加一个间接级别，而以最小的开销(语法和运行时)干净地完成该任务的一种方法是使用一些实用程序来创建本地重载集，以便组件处理可以按类型进行简单的特殊处理。下面是一个基本的实现，适用于所有的函函数(包括lambdas)，但不适用于函数指针:

template<typename FunT, typename... FunTs>
struct overloaded : private FunT, private overloaded<FunTs...> {
    overloaded() = default;
    template<typename FunU, typename... FunUs>
    overloaded(FunU&& f, FunUs&&... fs)
      : FunT(std::forward<FunU>(f)),
        overloaded<FunTs...>(std::forward<FunUs>(fs)...)
    { }
    using FunT::operator();
    using overloaded<FunTs...>::operator();
};
template<typename FunT>
struct overloaded<FunT> : private FunT {
    overloaded() = default;
    template<typename FunU>
    overloaded(FunU&& f) : FunT(std::forward<FunU>(f)) { }
    using FunT::operator();
};
template<typename... FunTs>
overloaded<std::decay_t<FunTs>...> overload(FunTs&&... fs) {
    return {std::forward<FunTs>(fs)...};
}

如果需要，可以在网上找到更健壮的overload实现，但即使有这个简单的实现，我们现在也可以做以下事情:

struct AIComponent      { void update() { } };
struct PhysicsComponent { void update() { } };
struct RenderComponent  { void render() { } };
class Game {
    using ComponentTypes = std::tuple<AIComponent, PhysicsComponent, RenderComponent>;
    static constexpr std::size_t MAX_NUM = 3;
    ComponentPool<MAX_NUM, ComponentTypes> componentPool;
    std::atomic_bool gameOver{false};
public:
    void runGame() {
        // `auto` overload is the least specialized so `update()` is the default
        static auto process = overload(
            [](           auto& comp) { comp.update(); },
            [](RenderComponent& comp) { comp.render(); }
        );
        while (!gameOver) {
            for_each(componentPool, [](auto& components) {
                std::for_each(begin(components), end(components), process);
                // alternatively, equivalently:
                //for (auto& component : components) {
                //    process(component);
                //}
            });
        }
    }
    void endGame() { gameOver = true; }
};

在线演示

现在您需要管理MAX_NUM和ComponentTypes，并且还可能为process添加一个新的重载(尽管如果您忘记了，您将得到一个编译器错误)。

#include <vector>
#include <iostream>

struct ComponentInterface {
    virtual void update();
};
struct AIComponent : public ComponentInterface {
    virtual void update() override {
        std::cout << "AIComponentn";
    }
};
struct GraphicsStuff {};
public RenderComponent : public GraphicsStuff, ComponentInterface {
    virtual void update() override {
        std::cout << "Rendern";
    }
};
int main() {
    std::vector<ComponentInterface*> components;
    AIComponent ai;
    RenderComponent render;
    components.push_back(&ai);
    components.push_back(&render);
    for (auto&& comp: components) {
        comp->update();
    }
}