web-dev-qa-db-ja.com

テンプレート引数に基づくコードの条件付きコンパイル時の包含/除外？

次のクラスを考えてみましょう。内部構造体Yが型として使用されています。テンプレートでは、後で：

template<int I>
class X{
  template<class T1>
  struct Y{};

  template<class T1, class T2>
  struct Y{};
};

さて、この例は明らかにコンパイルされません。2番目のX<I>::Yがすでに定義されているか、テンプレートパラメータが多すぎるというエラーがあります。
（追加の）部分的な特殊化なしでそれを解決したいと思います。int Iパラメーターだけではなく、その位置は部分的な特殊化によって異なる可能性があるためです（私の実際の構造体は- もっとこのように 、上記は質問を簡単にするためのものです）、それで私はone class fits every Iソリューションが欲しいです。

私の最初の考えは明らかにenable_ifでしたが、それは私には失敗しているようです。それでも同じエラーが発生します：

// assuming C++11 support, else use boost
#include <type_traits>

template<int I>
class X{
  template<class T1, class = std::enable_if<I==1>::type>
  struct Y{};

  template<class T1, class T2, class = std::enable_if<I==2>::type>
  struct Y{};
};

したがって、enable_ifは失敗するので、次のコンパイル時チェックを実現する別の方法があることを願っています。

template<int I>
class X{
  __include_if(I == 1){
    template<class T1>
    struct Y{};
  }

  __include_if(I == 2){
    template<class T1, class T2>
    struct Y{};
  }
};

コードの重複をたくさん節約するだけですが、どういうわけか可能であれば本当に嬉しいです。
編集：残念ながら、Visual Studio 2010を使用しているため、明白な可変個引数テンプレートを使用できません。そのため、そこでサポートされているC++ 0xのものだけを使用できます。 ：/

c++templatesconditional-compilationcompile-time
25
Xeo

ここには2つの問題があります。

  1. enable_ifは、プライマリテンプレートではなく、部分的な特殊化で機能します。
  2. 外部から見える引数の数は、プライマリテンプレートによって決定されますが、プライマリテンプレートは1つしかない場合があります。

回答1。

チャットで提案したように、テンプレートのリンクリストは可変個引数パラメータパックをエミュレートできます。

template<int I>
class X{
  template<class list, class = void>
  struct Y;

  template<class list>
  struct Y< list, typename std::enable_if<I==1>::type > {
      typedef typename list::type t1;
  };

  template<class list>
  struct Y< list, typename std::enable_if<I==2>::type > {
      typedef typename list::type t1;
      typedef typename list::next::type t2;
  };
};

next::next::nextガベージが発生した場合は、メタ関数を記述したり、BoostMPLを使用したりするのは簡単です。

回答2。

異なるアリティのテンプレートにも同様の名前を付けることができますが、SFINAEで制御されるタイプ内にネストされている場合は区別されます。

template<int I>
class X{
  template<typename = void, typename = void>
  struct Z;

  template<typename v>
  struct Z< v, typename std::enable_if<I==1>::type > {
      template<class T1>
      struct Y{};
  };

  template<typename v>
  struct Z< v, typename std::enable_if<I==2>::type > {
      template<class T1, class T2>
      struct Y{};
  };
};

X<1>::Z<>::Y< int > a;
X<2>::Z<>::Y< char, double > b;
8
Potatoswatter

どうぞ：

http://ideone.com/AdEfl

そしてコード：

#include <iostream>

template <int I>
struct Traits
{
  struct inner{};
};

template <>
struct Traits<1>
{
  struct inner{
    template<class T1>
    struct impl{
      impl() { std::cout << "impl<T1>" << std::endl; }
    };
  };
};

template <>
struct Traits<2>
{
  struct inner{
    template<class T1, class T2>
    struct impl{
      impl() { std::cout << "impl<T1, T2>" << std::endl; }
    };
  };
};

template<class T>
struct Test{};

template<class T, class K>
struct Foo{};

template<int I>
struct arg{};

template<
  template<class, class> class T,
  class P1, int I
>
struct Test< T<P1, arg<I> > >{
  typedef typename Traits<I>::inner inner;      
};

template<
  template<class, class> class T,
  class P2, int I
>
struct Test< T<arg<I>, P2 > >{
  typedef typename Traits<I>::inner inner;      
};

// and a bunch of other partial specializations

int main(){

  typename Test<Foo<int, arg<1> > >::inner::impl<int> b;
  typename Test<Foo<int, arg<2> > >::inner::impl<int, double> c;
}

説明：基本的には部分的な特殊化の概念の拡張ですが、違いは、Test内で特殊化するのではなく、Iだけに特化できる特定のクラスに委任することです。そうすれば、inneronceごとにIのバージョンを定義するだけで済みます。その後、Testの複数の特殊化を再利用できます。 innerホルダーは、typedefクラスのTestを扱いやすくするために使用されます。

編集：これは、間違った数のテンプレート引数を渡した場合に何が起こるかを示すテストケースです： http://ideone.com/QzgNP

3
Nim

以下を試すことができますか（部分的な特殊化ではありません）：

template<int I>
class X
{
};

template<>
class X<1>
{
  template<class T1>
  struct Y{};
};

template<>
class X<2>
{
  template<class T1, class T2>
  struct Y{};
};

答えがそんなに単純なのか疑問です!!

編集（モック部分特殊化）：@ Xeo、次のコードをコンパイルできましたが、いっぱいになっているようです。

template<int I>
struct X
{
  struct Unused {};  // this mocking structure will never be used

  template<class T1, class T2 = Unused>  // if 2 params passed-->ok; else default='Unused'
  struct Y{};

  template<class T1> 
  struct Y<T1, Unused>{}; // This is specialization of above, define it your way
};

int main()
{
  X<1>::Y<int> o1;  // Y<T1 = int, T2 = Unused> called
  X<2>::Y<int, float> o2; // Y<T1 = int, T2 = float> called
}

ただし、ここでは、X <1>、X <2>を同じ意味で使用できます。しかし、あなたが言及したより広い例では、それは無関係です。それでも必要に応じて、I = 1とI = 2のチェックを入れることができます。

1
iammilind

メタ関数（ここでは、インラインboost::mpl::if_cですが、任意に複雑にすることができます）を使用して、必要な関数を選択できます。ただし、コンストラクターを使用できるようにするには、いくつかのスキャフォールディングが必要です。

template <int I>
class X {
    template <typename T1>
    class YforIeq1 { /* meat of the class */ };
    template <typename T1, typename T2>
    class YforIeq2 { /* meat of the class */ };
public:
    template <typename T1, typename T2=boost::none_t/*e.g.*/>
    struct Y : boost::mpl::if_c<I==1,YforIeq1<T1>,YforIeq2<T1,T2> >::type {
        typedef typename mpl::if_c<I==1,YforIeq1<T1>,YforIeq2<T1,T2> >::type YBase;
        /* ctor forwarding: C++0x */
        using YBase::YBase;
        /* ctor forwarding: C++03 (runs into perfect fwd'ing problem)*/
        Y() : YBase() {}
        template <typename A1>
        Y(const A1&a1) : YBase(a1) {}
        template <typename A1, typename A2>
        Y(const A1&a1, const A2&a2) : YBase(a1,a2) {}
        // ...
    };
};

両方のYforIeq[〜＃〜] n [〜＃〜]がXごとにインスタンス化されることに問題がある場合は、それらをnullaryメタ関数（何かに沿ったもの）としてラップしてみることができます。 mpl::applyと同じように）、mpl::eval_if_cを使用します。

0
Marc Mutz - mmutz

このアプローチはどうですか- http://sergey-miryanov.blogspot.com/2009/03/template-class-overriding.html ？ （ロシア語でごめんなさい）

0
W55tKQbuRu28Q4xv