0

我正在使用 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 还不够强大（还）。

根据 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 的项目，并且因为复制整个模板的选项是维护的噩梦。但他们都完成了工作。我将考虑将 boost 解决方案作为答案，仅仅是因为希望 boost 代码将成为标准，因此不那么令人头疼。

谢谢你们。

4

2 回答 2

1

Your question is very wordy and I'm not sure if I'm understanding correctly, but I'll give it a try.

I think you want to specialize M2 for the case of a template 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> { };

In this example, M2 is specialized for M1<B> by using a nested template (B) to allow it to accept any instantiation of the M1 template.

于 2011-04-01T22:49:32.103 回答
1

正如 dauphic 所建议的那样，您可以只对 M2 类的参数为 M1 的情况进行部分特化，当然，您可以对 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 回答