特殊化をあまりにも制限するC++テンプレート宣言

Question

私は現在の問題を簡単に説明しようとします。それは簡単に解決することができましたが、私が今までに見つけた唯一の解決策は自分自身を満足させるものではありません。解決に必要となる間接化の次のレベルを私に示します。

私はそれが問題の核心ではない場合でも、ここでCRTPを使用します。ここに私の問題を再現するコードの一部は次のとおりです。

template <typename T> 
class A 
{ 
    public: 
     static void p() 
     { 
      T::p(); 
     } 
}; 

template <typename T> 
class B 
{ 
    public: 
     static void q() 
     { 
      T::q(); 
     } 
}; 



????? template <??????> ???? // How to declare C here ??? 
class C; 


//now first specializations with A 
template <int a> 
class C<a> : public A<C<a> > 
{ 
    public: 
     static void p() 
     { 
      //specific stuff 
     } 
}; 

template <int a, typename Other_handlers ...> 
class C<a, Other_handlers...> : public A<C<a, Other_handlers...> > 
{ 
    public: 
     static void p() 
     { 
      //specific stuff 
     } 
}; 

template <int a, typename Child> 
class C<a, B<Child> > : public A<C<a, B<Child> > > 
{ 
    public: 
     static void p() 
     { 
      //specific stuff 
     } 
}; 



//second specializations with B 
template <int a, int b> 
class C<a, b> : public B<C<a, b> >, C<a> 
{ 
    public: 
     static void q() 
     { 
      //specific stuff 
     } 
}; 

template <int a, int b, typename Other_handlers ...> 
class C<a, b, Other_handlers...> : public B<C<a, b, Other_handlers...> >, C<a> 
{ 
    public: 
     static void q() 
     { 
      //specific stuff 
     } 
}; 

template <int a, int b, typename Child> 
class C<a, b, B<Child> > : public B<C<a, b, B<Child> > >, C<a> 
{ 
    public: 
     static void p() 
     { 
      //specific stuff 
     } 
}; 

コードのこの作品の目標は、テンプレートパラメータに依存Cでいくつかのメソッドを持っているだろう（ここでC<1,2>は両方AとBクラスのメソッドを持っているでしょうC<1>だけAのものを持っているでしょうに対しC<1, 2, C<3> >の両方を持つことになり、一方、その後、C<1, C<1,2> >は）...など、Aのものだけを持っているでしょう。 私が失敗するところは、値と型の両方のテンプレートパラメータ（この場合はint型と型、混在型）をサポートするのに十分な一般的なものを宣言する方法がわからないので、その専門化前のCの宣言にあります。 私は

template <typename ... Args> 
class C; 

を宣言した場合、それは明らかにint型を解析失敗したので。

そして

template <int a, int b, typename ... Args> 
class C; 

は明らかに一つだけintパラメータで専門で型を解析する失敗します。

template <int a, typename ... Args> // allows first specialisations 
class C; 
template <int a, int b, typename ... Args> //allows second specialisations 
class D; 

しかし、私は唯一の宣言にグループ化したいと思います：

だから、私が今まで見つけた唯一の解決策は、Cするのではなく、2つの異なるタイプを宣言することです。出来ますか ？

ありがとうございます！

PS：あなたはそれが私が知っているために任意のより良い提案を持っている場合ちなみに、私が選んだタイトルは、非常に悪いです！私は唯一の1つの宣言にグループ結果の型の使用状況にあなたを可能にするマクロ含む醜いソリューションを考えることができ

Answer 1

私は想像することができる最高の唯一のタイプ

template <typename ...> 
class C; 

に受けるよう Cを宣言しています

ダミー型（またはstd::integer_sequenceを使用して）初期整数値をラップ

template <int ...> 
struct Ci 
{ }; 

明らか

以前C<1>（例による）としてCの宣言、

C<1> c1; 

が

C<Ci<1>> c1; 

次のコードは醜いになるが、

template <typename> class A {}; 
template <typename> class B {}; 

template <typename ...> 
class C; 

template <int ...> struct Ci {}; 

template <int a> 
class C<Ci<a>> : public A<C<Ci<a>>> 
{ }; 

template <int a, typename ... Other_handlers> 
class C<Ci<a>, Other_handlers...> : public A<C<Ci<a>, Other_handlers...>> 
{ }; 

template <int a, typename Child> 
class C<Ci<a>, B<Child>> : public A<C<Ci<a>, B<Child>>> 
{ }; 

template <int a, int b> 
class C<Ci<a, b>> : public B<C<Ci<a, b>> >, C<Ci<a>> 
{ }; 

template <int a, int b, typename ... Other_handlers> 
class C<Ci<a, b>, Other_handlers...> 
    : public B<C<Ci<a, b>, Other_handlers...>>, C<Ci<a>> 
{ }; 

template <int a, int b, typename Child> 
class C<Ci<a, b>, B<Child> > : public B<C<Ci<a, b>, B<Child> > >, C<Ci<a>> 
{ }; 


int main() 
{ 
    C<Ci<1>> c1; 
} 

Answer 2

：

template<int V> struct 
fooIntImpl 
{ 
}; 

template<int V> fooIntImpl<V> 
foo_deduce_helper(void); 

template<typename T> struct 
fooTypeImpl 
{ 
}; 

template<typename T> fooTypeImpl<T> 
foo_deduce_helper(void); 

#define foo(template_parameters) decltype(foo_deduce_helper<template_parameters>()) 

int main() 
{ 
    foo(42) fooint; 
    foo(int) footype; 

    return 0; 
}