Question

我有一个模板类template<typename T> class TplObject。我需要一种静态结构类型的数组，索引是typename T。我可以这样做：

array.add<Type1>(); // New Object of type TplObject<Type1> was added
TplObject<Type1> obj = array.get<Type1>();

是否有这样的结构，mb在boost？如果不是，你能建议如何制作吗？

Answer 1

您可能正在寻找std::type_index。结合std::shared_ptr，以下内容可帮助您入门：

class typemap
{
    std::map<std::type_index, std::shared_ptr<void>> map_;

public:
    template<typename T>
    void set(std::shared_ptr<T> obj)
    {
        map_[std::type_index(typeid(T))] = obj;
    }

    template<typename T, typename... Args>
    void emplace(Args&&... args)
    {
        this->set(std::make_shared<T>(std::forward<Args>(args)...));
    }

    template<typename T>
    std::shared_ptr<T> get()
    {
        return std::static_pointer_cast<T>(map_[std::type_index(typeid(T))]);
    }
};

这个例子可以容纳每种类型的一个对象，使用它做这样的事情：

typemap m;

// set
m.set( std::make_shared< int >( 42 ) );
m.set( std::make_shared< MyClass >() );
m.set( std::make_shared< std::vector<double> >() );

// or use emplace
m.emplace<int>( 42 );
m.emplace< MyClass >();
m.emplace< std::vector<double> >();

// access
int douglas = *m.get< int >();
m.get< MyClass >()->adams();
m.get< std::vector<double> >()->push_back( 3.141592 );

Answer 2

所以这是做这样的事情的一个例子。我获取一个类型列表来实例化一个模板，用它们实例化一个模板，将实例存储在一个元组中，并提供一个基于类型的查找get方法。

#include <type_traits>
#include <utility>
#include <tuple>

// Metaprogramming boilerplate:
template<typename... Ts> struct type_list {};
template<typename T, typename list, typename=void> struct index_in;
template<typename T, typename T0, typename... Ts>
struct index_in<T, type_list<T0, Ts...>, typename std::enable_if<std::is_same<T,T0>::value>::type>
{
  enum { value = 0 };
};
template<typename T, typename T0, typename... Ts>
struct index_in<T, type_list<T0, Ts...>, typename std::enable_if<!std::is_same<T,T0>::value>::type>
{
  enum { value = index_in<T, type_list<Ts...>>::value+1 };
};

// The tuple of instantiations of Factory:
template<template<typename>class Factory, typename... Ts>
struct PolytypeFactory {
  std::tuple< Factory<Ts>... > data;
  template<typename T>
  Factory<T>& get() {
    return std::get< index_in< T, type_list<Ts...> >::value >( data  );
  }
  template<typename T>
  Factory<T> const& get() const {
    return std::get< index_in< T, type_list<Ts...> >::value >( data  );
  }
};

// a test factory, that creates an instance of T from the constant 100.5:
template<typename T> struct maker100_5 { T operator()() const { return T(100.5); } };

// test code, where I create 100.5 as an int, double and char, then print them:
#include <iostream>
int main() {
   PolytypeFactory<maker100_5, int, double, char> factory;
   std::cout << factory.get<int>()() << "," << factory.get<double>()() << "," << factory.get<char>()() << "\n";
}

如果需要，您可以推迟构建PolytypeFactory的内容，方法是使用boost::optional，将指针存储到Factory<Ts>并允许某人传入new版本通过类似get()的方法，或者非常喜欢并进行就地构建。

模板类的静态对象数组

2 个答案: