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

Question

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

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？

我怀疑有一种使用模板方法和特化的方法，但我的模板功能还不够强大。

---

根据 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<> 模板不处理 bool 表达式(对我来说)，所以我去了使用 disable_if<>，这似乎可以解决问题。

这些都不是特别令人高兴的事情，因为这段代码将被贡献给一个当前不使用 boost 的项目，并且因为复制整个模板的选项是维护的噩梦。但他们确实都完成了工作。我将考虑使用 boost 解决方案作为答案，只是因为希望 boost 代码成为标准，从而减少头痛。

谢谢大家

Answer 1

正如 dauphic 所建议的，当 M2 类的参数是 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();
};