在模板中使用派生类并将其存储到基类的向量中

Question

我正在尝试使用 std::map 和存储类型的 Type 类在 C++ 中创建类型映射。然后有一个基类 Base 和一些我想要存储的派生类。

template <typename T>
class Type {

public:
    Type() {}

    virtual ~Type() {}
    virtual T* allocate() const { return new T; }
    virtual T* cast(void *object) const { return static_cast<T*>(object); }
};

这很好用：

map<int, Base*> typeMap;
typeMap[1] = new Derive();

但是当试图做这样的事情时，我得到了错误：“Type *”类型的值不能分配给“Type *”类型的实体

map<int, Type<Base>*> typeMap;
typeMap[1] = new Type<Derive>();

有没有机会存储这样的东西？我不想要任何库解决方案（非开源）

Answer 1

类似于@pmr 的回答，但使用std::tuple

#include <tuple>
#include <type_traits>

class Base{};
class Derived : public Base {};

template<std::size_t i>
struct my_map
{
private:
    using myTuple = std::tuple<Base, Derived>;
public:
    using type = typename std::tuple_element<i, myTuple>::type;
};

static_assert(std::is_same<Base, my_map<0>::type>::value, "bad type");
static_assert(std::is_same<Derived, my_map<1>::type>::value, "bad type");

Answer 2

将struct 指定为您要映射的每种类型的整数。

#include <cstddef> // size_t

struct Base {};
struct Derived : Base {};

template<std::size_t i>
struct my_map;

// specialize the map (maybe shorten with a macro)
template<>
struct my_map<0> {
  using type = Base;
};

template<>
struct my_map<1> {
  using type = Derived;
};

// easier to use, if you compiler supports it:
template<std::size_t i>
using my_map_t = typename my_map<i>::type;


int main()
{
  my_map<0>::type* b1 = new Base();
  my_map<0>::type* b2 = new Derived();
  my_map<1>::type* d1 = new Derived();
  // my_map<1>::type* d2 = new Base(); error wrong type

  // prettier
  my_map_t<0>* b3 = new Base();

  return 0;
}