C++ 类型的编译时静态数组

我试图在编译时构建一个由动态数组组成的静态数组。一些例子：

struct Apple {
  int x;
};

struct Pear {
  int a, b;
};

然后

Registry<Apple, Pear> registry;
auto appleId = registry.add<Apple>(1);
auto pearId = registry.add<Pear>(1, 2);

Apple* apple = registry.get<Apple>(appleId);

或者

…虽然第二个示例在编译时可能更难执行

我假设内部的数据结构如下所示：

template <typename... Ts>
struct Registry {
  std::array<std::vector<?>, sizeof...(Ts)> values;
};

关于如何开始探索这个问题有什么想法吗？

std:：vector只能包含相同类型的元素。另一方面，std:：tuple可以包含不同类型的元素：

template<typename... Ts>
struct Registry {
    std::tuple<std::vector<Ts>...> values;

    template<class T, class... Args>
    size_t add(Args&&... args) {
        auto& v = std::get<std::vector<T>>(values);
        auto idx = v.size();
        v.emplace_back(std::forward<Args>(args)...);
        return idx;
    }

    template<class T>
    T* get(size_t idx) {
        auto& v = std::get<std::vector<T>>(values);
        return idx < v.size() ? &v[idx] : 0;
    }
};

int main() {
    Registry<Apple, Pear> registry;
    auto appleId = registry.add<Apple>(1);
    auto pearId = registry.add<Pear>(1, 2);
    Apple* apple = registry.get<Apple>(appleId);
}

---

然而，在C++17中操作这样的注册表只是在运行时进行的。

在编译时生成动态的东西意味着什么？听起来好像您需要std:：tuple，以及一些方便的函数。是吗？你真的需要一个所有东西的通用注册表吗？为什么不把注册表和注册表分开呢？或者你需要在这里继承。苹果和梨的超类水果。不清楚你想如何使用它。但似乎您需要一个std:：tuple。

template<typename... Ts>
struct Registry {
    std::tuple<std::vector<Ts>...> values;

    template<class T, class... Args>
    size_t add(Args&&... args) {
        auto& v = std::get<std::vector<T>>(values);
        auto idx = v.size();
        v.emplace_back(std::forward<Args>(args)...);
        return idx;
    }

    template<class T>
    T* get(size_t idx) {
        auto& v = std::get<std::vector<T>>(values);
        return idx < v.size() ? &v[idx] : 0;
    }
};

int main() {
    Registry<Apple, Pear> registry;
    auto appleId = registry.add<Apple>(1);
    auto pearId = registry.add<Pear>(1, 2);
    Apple* apple = registry.get<Apple>(appleId);
}