3

私は現在、新しい c++0x 可変個引数テンプレートを使用しており、非常に楽しいですが、メンバーのインスタンス化のプロセスについて質問があります。

この例では、強く型付けされた列挙型をエミュレートして、ランダムで有効な強力な列挙型を選択できるようにしようとしています (これは単体テストに使用されます)。


#include<vector>
#include<iostream>

using namespace std;

template<unsigned... values> struct sp_enum;

/*
 this is the solution I found, declaring a globar var
 vector<unsigned> _data;

 and it work just fine

*/

template<> struct sp_enum<>{
  static const unsigned _count  = 0;
  static vector<unsigned> _data;
};

vector<unsigned> sp_enum<>::_data;

template<unsigned T, unsigned... values>
struct sp_enum<T, values...> : private sp_enum<values...>{
  static const unsigned _count = sp_enum<values...>::_count+1;
  static vector<unsigned> _data;

  sp_enum(                       ) : sp_enum<values...>(values...) {_data.push_back(T);}
  sp_enum(unsigned v             )                                 {_data.push_back(v);}
  sp_enum(unsigned v, unsigned...) : sp_enum<values...>(values...) {_data.push_back(v);}
};

template<unsigned T, unsigned... values> vector<unsigned> sp_enum<T, values...>::_data;

int main(){
  enum class t:unsigned{Default = 5, t1, t2};
  sp_enum<t::Default, t::t1, t::t2> test;
  cout <<test._count << endl << test._data.size() << endl;  
  for(auto i= test._data.rbegin();i != test._data.rend();++i){cout<< *i<< ":";}
}

このコードで得られる結果は次のとおりです。

3
1
5:

誰かが私がここで混乱していることを指摘できますか???

Ps: gcc 4.4.3 を使用

私はコードをより一般的になり、ハードコアコーディングを可能な限り減らすために作り直しました（@Matthieu M.）。しかし、なぜ私が以前にこれをすべて行っているのかを説明したいと思います。

多くの開発者が私のコードで新しい c++0x 標準を採用したので、私はそれについて満足していません。しかし、テスト ユニットを作成しようとすると、厳密に型指定された列挙型に問題があります。

問題は、強い型付けされたランダムな列挙型を生成できないことです (生成できることはわかっていますが、よりエレガントな方法で生成したいと考えていました)。したがって、このコードでは、可変個引数テンプレートと可変個引数マクロ (古いダーティ マクロ) を使用して、厳密に型指定されスコープが設定された列挙型を宣言し、ランダムに選択できます。

コードは次のとおりです。


#include<vector>
#include<iostream>

#include <boost/preprocessor/array/elem.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/repeat_from_to.hpp>

using namespace std;

template<typename T, T... values> class sp_enum;

template<typename T> class sp_enum<T>{
  protected: static const unsigned _count  = 0;
};

template<typename T, T head, T... values>
class sp_enum<T, head, values...> : public sp_enum<T, values...>{
protected:
  static const unsigned _count = sp_enum<T, values...>::_count+1;
  static vector<T> _data;

public:
  sp_enum(         ) : sp_enum<T, values...>(values...) {_data.push_back(head);for(auto i= sp_enum<T, values...>::_data.begin();i != sp_enum<T, values...>::_data.end();++i){_data.push_back(*i);}}
  sp_enum(T v      )                                    {_data.push_back(v   );}
  sp_enum(T v, T...) : sp_enum<T, values...>(values...) {_data.push_back(v   );for(auto i= sp_enum<T, values...>::_data.begin();i != sp_enum<T, values...>::_data.end();++i){_data.push_back(*i);}}

  vector<T> data()  const { return _data  ;}
  unsigned  count() const { return _count ;}

  static T randomEnum() { srand (time(NULL));return _data[rand()%_count];}

};

template<typename T, T head, T... values> vector<T> sp_enum<T, head, values...>::_data;

#define PP_NARG(...)  PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...) PP_ARG_N(__VA_ARGS__)

#define PP_ARG_N( \
         _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
        _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
        _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
        _61,_62,_63,N,...) N

#define PP_RSEQ_N() \
        63,62,61,60,59,58,57,56,55,54,53,52,51,50,49,48,47,46,45,44,43,42,41,40, \
        39,38,37,36,35,34,33,32,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16, \
        15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0

#define FOREACH_ARRAY( ... )  (PP_NARG(__VA_ARGS__) , ( __VA_ARGS__ ) )
#define FOREACH( Name, A, ... )     BOOST_PP_REPEAT_FROM_TO(1, PP_NARG(Name, __VA_ARGS__), A, FOREACH_ARRAY(Name, __VA_ARGS__) )
#define DECORATION(z,n,data)  ,BOOST_PP_ARRAY_ELEM( 0, data ) :: BOOST_PP_ARRAY_ELEM( n, data ) 

#define SP_ENUM(enumName, ...)                                \
  enum class _##enumName : unsigned { Default, __VA_ARGS__ }; \
  typedef sp_enum<_##enumName FOREACH( _##enumName, DECORATION, Default, __VA_ARGS__) > enumName;

SP_ENUM( xx, test1, test2, test3 )

int main(){
  xx test;
  cout <<test.count() << endl << test.data().size() << endl; 
  auto dt = test.data();
  for(auto i = dt.rbegin(); i != dt.rend();++i){ cout<< (unsigned)*i << ":" ; }
  cout << "random strongly typed enum : " << (unsigned) test.randomEnum() << endl;
}

今私を悩ませているのは、PP_NARG マクロの制限です (引数の数を数える他の方法は見つかりませんでした)。

これを強化するためのポインタやヒントを喜んで受け入れます.

4

4 に答える 4

5

static vector<unsigned> _data;sp_enum インスタンス間では共有されず、同じパラメーターを持つテンプレート クラスのインスタンス間でのみ共有されます。

于 2010-04-08T10:40:05.207 に答える
1

この質問はめちゃくちゃになったので。

あなたはこのようなものを求めていますか？申し訳ありませんが、boost のプリプロセッサ ライブラリはわかりませんが、特に必要ではないようです。唯一の問題は、count がコンパイル時の定数である必要があるかどうかです。

#include<vector>
#include<iostream>
#include <cstdlib>

#define DECLARE_ENUM(enum_name, ...) \
enum class enum_name##_ : unsigned { __VA_ARGS__}; \
class enum_name { \
public: \
     static enum_name##_ random() { return static_cast<enum_name##_>(values[rand() % values.size()]); } \
     static unsigned count() { return values.size(); } \
     static std::vector<unsigned> data() { return values; } \
private: \
     enum : unsigned {__VA_ARGS__}; \
     static std::vector<unsigned> values; \
}; \
std::vector<unsigned> enum_name::values{__VA_ARGS__};

DECLARE_ENUM( xx, test1, test2, test3 )

int main(){
  xx test;
  std::cout <<test.count() << std::endl << test.data().size() << std::endl;
  auto dt = test.data();
  for(auto i = dt.rbegin(); i != dt.rend();++i){ std::cout<< (unsigned)*i << ":" ; }
  xx_ random_value = test.random();
  std::cout << "random strongly typed enum : " << (unsigned) random_value << std::endl;
}

確かに、デザインはより良いものになる可能性があり、デフォルトのアイデアについては気にしませんでした (連続した値が必要ない場合は、とにかく壊れます)。

もう1つ、これが連続する値のみをサポートする場合、そもそもベクトルの理由はありません。最初の値 (常に 0 ではない場合) と最後の値を保存するだけで、他のすべてを計算できます。data メソッドは、boost の範囲を返す場合がありますcounting_iterator。

または、対応する特性クラスを特殊化します。

#include<iostream>
#include <cstdlib>

namespace detail {
template <unsigned ...values>
struct last;

template <unsigned N, unsigned ...values>
struct last<N, values...>
{
    static const unsigned value = last<values...>::value;
};

template <unsigned N>
struct last<N>
{
    static const unsigned value = N;
};

template <unsigned N, unsigned ...>
struct first
{
    static const unsigned value = N;
};
}
template <class T>
struct enum_traits;

#define DECLARE_ENUM(enum_name, ...) \
enum class enum_name : unsigned { __VA_ARGS__}; \
template <> struct enum_traits<enum_name> { \
private: enum : unsigned { __VA_ARGS__ }; \
public: \
     static const unsigned first = detail::first< __VA_ARGS__>::value; \
     static const unsigned last =  detail::last< __VA_ARGS__>::value; \
     static const unsigned count = last - first + 1; \
};

template <class T>
T random_enum_value()
{
    return static_cast<T>(rand() % enum_traits<T>::count + enum_traits<T>::first);
}

DECLARE_ENUM( xx, test1, test2, test3 )

int main(){
    std::cout << enum_traits<xx>::first << ' ' << enum_traits<xx>::last << ' ' << enum_traits<xx>::count << '\n';
    std::cout << (unsigned) random_enum_value<xx>() << '\n';
}
于 2010-04-08T19:51:12.887 に答える
0

vector一般的な注意点として、ここでの主な問題は、列挙ごとに 1 つのインスタンスが必要になることです(ロジックですね?)。

たとえば、2 つの列挙型を使用する場合、修正は機能しません。

したがって、行うべき論理的なことは、次のようなものになります。

template <class Enum>
struct sp_enum_vector { static std::vector<unsigned> _data; };

次に、列挙型クラスを次のように変更します。

template <class Enum, unsigned... values>
struct sp_enum;

話している列挙型に応じてクラスを区別するため。

次の質問: どうやって から を取得しunsignedますtか? それをハードコードするのは悪いことです:p

于 2010-04-08T11:46:25.663 に答える
0

Pavel のおかげで、問題が解決しました。

ここに解決策があります


#include<vector>
#include<iostream>

using namespace std;

template<unsigned... values> struct sp_enum;

template<> struct sp_enum<>{
  static const unsigned _count  = 0;
  static vector<unsigned> _data;
};

vector<unsigned> sp_enum<>::_data;

template<unsigned T, unsigned... values>
struct sp_enum<T, values...> : private sp_enum<values...>{
  static const unsigned _count = sp_enum<values...>::_count+1;
  static vector<unsigned> _data;

  sp_enum(                       ) : sp_enum<values...>(values...) {_data.push_back(T);for(auto i= sp_enum<values...>::_data.begin();i != sp_enum<values...>::_data.end();++i){_data.push_back(*i);}}
  sp_enum(unsigned v             )                                 {_data.push_back(v);}
  sp_enum(unsigned v, unsigned...) : sp_enum<values...>(values...) {_data.push_back(v);for(auto i= sp_enum<values...>::_data.begin();i != sp_enum<values...>::_data.end();++i){_data.push_back(*i);}}

};

template<unsigned T, unsigned... values> vector<unsigned> sp_enum<T, values...>::_data;

int main(){
  enum class t:unsigned{Default = 5, t1, t2};
  sp_enum<t::Default, t::t1, t::t2> test;
  cout <<test._count << endl << test._data.size() << endl;  
  for(auto i= test._data.rbegin();i != test._data.rend();++i){cout<< *i<< ":";}
}

于 2010-04-08T11:02:39.950 に答える