Question

我正在使用C ++模板实现mixins，以支持基类（模板化）类的一些“扩展”行为。

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

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

如果继承图中存在另一个mixin，我需要修改一个mixin中的行为。（理想情况下，这将不考虑哪一个首先混合，但我愿意接受他们必须以特定顺序派生的限制。）

换句话说，如果我有：

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

当M1混入时，M2方法的行为需要改变 - M1提供了需要用于计算M2结果的数据成员。另一方面，如果没有混合M2，则M2对那些完全无效的数据成员提供某些保证。

那么，我的问题是如何实现这个C ++ '03？

我怀疑有一种方法可以使用模板方法和专门化，但我的模板fu还不够强大（还）。

Per 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＆lt;＆gt;模板不处理布尔表达式（对我来说），所以我去了使用disable_if＆lt;＆gt;，这似乎可以解决问题。

这些都不是特别开心，因为这个代码将被贡献给当前不使用boost的项目，并且因为复制整个模板的选项是维护噩梦。但他们都完成了工作。我将考虑将增强解决方案作为答案，因为希望增强代码将成为标准，因此不那么令人头痛。

谢谢大家。

Answer 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模板的任何实例化。

Answer 2

正如dauphic建议的那样，当它的参数是M1时，你可以对M2类进行部分特化，当然，你可以对M1做同样的事情（通过简单的声明交错）。 / p>

但是，这将为您提供非常粗粒度的专业化，即您必须重新定义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();
};

如何在两个mixin模板之间实现多态行为？

2 个答案: