0

基本（テンプレート）クラスのいくつかの「拡張」動作をサポートするために、C++テンプレートを使用してミックスインを実装しています。

template< class Ch > Base {...};

template< class T > M1 : public T {...};
template< class T > M2 : public T {...};
// etc.

継承グラフに別のミックスインが存在する場合は、1つのミックスインの動作を変更する必要があります。（理想的には、これはどちらが最初に混合されたかには関係ありませんが、特定の順序で派生する必要があるという制限を受け入れます。）

言い換えれば、私が持っている場合：

typedef Base< char > base;
typedef M2< M1< base >> foo;
typedef M2< base > bar;

M1が混在している場合、M2メソッドの動作を変更する必要があります-M1は、M2結果の計算に使用する必要のあるデータメンバーを提供します。一方、M2は、M2が混在していない場合に完全に無効になるデータメンバーについて一定の保証を行います。

では、私の質問は、このC ++'03をどのように実装するかということです。

テンプレートメソッドと特殊化を使用する方法があると思いますが、私のtemplate-fuは（まだ）十分に強力ではありません。

dauphicの応答に従って、私はこれを試しました、そしてそれはうまくいきます。M2テンプレートを完全に複製する必要があるのは恐ろしいので、次にSFINAEアプローチを試してみます。

#include <iostream>
#include <UnitTest++.h>

SUITE( Mixin_specialization_tests ) {

    template< typename Ch > struct Base {
        typedef Ch * pointer_type;
        pointer_type p;
    };

    template< class T > struct M1 : public T {
        typedef typename T::pointer_type pointer_type;
        pointer_type m1p;
    };

    template< class T > struct M2 : public T {
        typedef typename T::pointer_type pointer_type;
        pointer_type m2p;

        int compute( ) {
            std::cout << "unspecialized compute()" << std::endl;
            return 0;
        }
    };

    template< >
    template< class B > struct M2< M1<B> > : public M1<B> {
        typedef typename M1< B >::pointer_type pointer_type;
        pointer_type m2p;

        int compute( ) {
            std::cout << "specialized compute()" << std::endl;
            int unused = M1< B >::m1p - m2p;
            return 1;
        }
    };

    typedef Base< char > Bch;
    typedef M1< Bch > M1b;
    typedef M2< Bch  > M2b;
    typedef M2< M1< Bch > > M2m1b;

    TEST( unspecialized ) {
        M2b m2b;
        CHECK_EQUAL( 0, m2b.compute() );
    }

    TEST( specialized ) {
        M2m1b m2m1b;
        CHECK_EQUAL( 1, m2m1b.compute( ) );
    }
}

少し苦労した後、SFINAEバリアントも機能させることができました。この部分を除いて、コードはほとんど同じです。

    template< class Query > struct is_M1 {
    typedef char yes, (&no)[ 2 ];
    static no has_m1_member(...);

    template< class T, typename T::pointer_type T::* > struct dummy {};
    template< class T >
    static yes has_m1_member( T*, dummy<T, &T::m1p>* = 0 );
    BOOST_STATIC_CONSTANT( bool, value =
        ( sizeof( has_m1_member( ( Query * )0 ) ) == sizeof( yes ) )
    );
};

template< class T > struct M2 : public T {
    typedef typename T::pointer_type pointer_type;
    pointer_type m2p;

    int compute( ) {
        return compute_impl<T>( );
    }

    template< typename B >
    typename boost::enable_if< is_M1< B >, int >::type compute_impl( ) {
        std::cout << "sfinae: m1-compute" << std::endl;
        return 1;
    }

    template< typename B >
    typename boost::disable_if< is_M1<B>, int >::type compute_impl( ) {
        std::cout << "sfinae: non-m1-compute" << std::endl;
        return 0;
    }
};

以下で説明するように、enable_if <>テンプレートはブール式を処理しないため（私にとって）、disable_if<>を使用しました。これでうまくいくようです。

このコードは現在boostを使用していないプロジェクトに提供される予定であり、テンプレート全体を複製するオプションはメンテナンスの悪夢であるため、これらはどちらも特に満足のいくものではありません。しかし、彼らは両方とも仕事を成し遂げます。ブーストコードが標準になり、頭痛が少なくなることが期待されているという理由だけで、ブーストソリューションを答えと考えます。

皆さん、ありがとうございました。

4

2 に答える 2

1

あなたの質問は非常に言葉が多く、正しく理解しているかどうかはわかりませんが、試してみます。

M2テンプレートの場合に特化したいと思いますM1。

template<class T> class M1 : public T { };

template<class T> class M2 : public T { };
template<> template<class B> class M2<M1<B> > : public M1<B> { };

この例でM2は、はM1<B>、ネストされたテンプレート（B）を使用して、テンプレートのインスタンス化を受け入れることができるようにすることを目的としていますM1。

于 2011-04-01T22:49:32.103 に答える
1

dauphicが示唆したように、引数がM1の場合は、M2クラスの部分的な特殊化を行うことができます。もちろん、M1についても同じことができます（宣言の単純なインターリーブを使用）。

ただし、これにより、非常に粗い特殊化が得られます。つまり、M2のすべてのメンバーを再定義する必要があります。異なる必要のあるメンバーが少数しかない場合、つまり、このソリューションが適切に拡張できない場合、これは煩わしい場合があります。残念ながら、厄介なことに、C++はメンバー関数を個別に特殊化するためのサポートを提供していません。

それでも、Sfinaeがそれを支援するようになる可能性がありますが、もう少し作業が必要です。以下は基本的に、クラステンプレートの個々のメンバー関数の特殊化を可能にする古典的なSfinaeメソッドです。

#include <iostream>
#include <boost/utility/enable_if.hpp>
#include <boost/config.hpp>

template <class Model>
struct is_M1
{
    typedef char yes;
    typedef char (&no)[2];

    template <class T, void (T::*)()>
    struct dummy {};

    template <class T>
    static yes has_m1_function1(T*, dummy<T,&T::function1>* = 0);
    static no has_m1_function1(...); 

    BOOST_STATIC_CONSTANT(
        bool
      , value = sizeof( has_m1_function1((Model*)0) ) == 1 );
};

template <typename T>
struct Base { T value; };

template <typename T>
struct M1 : public T {
  void function1() { }; //I presume M1 would have at least one defining characteristic or member function
};

template <typename T>
struct M2 : public T {
  void function2() { function2_impl<T>(); };
  template <typename B>
  typename boost::enable_if< is_M1<B>, void>::type function2_impl() { 
    std::cout << "M1 is mixed in T" << std::endl;
  };
  template <typename B>
  typename boost::enable_if< !is_M1<B>, void>::type function2_impl() { 
    std::cout << "M1 is not mixed in T" << std::endl;
  };
};

int main() {
  M2< M1< Base<int> > > m2m1b;
  M2< Base<int> > m2b;

  m2b.function2();
  m2m1b.function2();
};
于 2011-04-02T03:51:55.897 に答える