1

テンプレートクラスがあり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はブーストされていますか？いいえの場合、それを作る方法を提案できますか？

4

2 に答える 2

0

あなたはおそらく探してい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))]);
    }
};

この例では、各タイプのオブジェクトを1つ保持して、次のように使用できます。

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 );
于 2013-03-22T20:01:36.270 に答える
0

だからここにこのようなことをする例があります。テンプレートをインスタンス化するためのタイプのリストを取得し、それらを使用してテンプレートをインスタンス化し、インスタンスをタプルに格納し、タイプベースのルックアップ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>を渡せるようにするか、または非常に凝ってインプレース構築を行うことができます。newget()

于 2013-03-22T20:26:32.547 に答える