0

我有三个类，它们遵循相同的概念类，但在用于存储的底层数据结构上有所不同。作为一个例子，采取下面给出的三个类。

template< typename T >
class A{
  std::vector<T> storage;
  //etc
};

template<>
class A<bool>{
  boost::dynamic_bitset<> storage;
  //etc
};

class B{
   ComplexUDT storage;
   //etc
};

A 类是使用向量的通用类。为避免使用vector<bool>A 类的完全特化，提供了使用boost::dynamic_bitset<>作为底层存储的 A 类。最后，B 类使用用户定义的数据类型作为存储。上面的设计导致了代码的大量冗余。为了消除这种冗余，我想到了使用 boost::mpl

template< typename T >
class vec_impl{
   std::vector< T >  storage;
   //impl of methods
};

class bitset_impl{
   boost::dynamic_bitset<> storage;
   //impl of methods
 };

 class udt_impl{
    ComplexUDT storage;
    //impl of methods
 };

 template<Derived,Storage>
 class main_class_gen{
     typedef typename boost::mpl::if_<is_complexudt<Storage>,
                                      udt_impl,
                                      typename boost::mpl::if_< is_bool<Storage>,
                                                                bitset_impl,
                                                                vec_impl<Storage> >::type >::type type
 };

 class main_class:
                  public main_class_gen< main_class<Storage>,Storage >::type{
        //impl. of methods
 };

由于 boost::dynamic_bitset 不为 Container 建模，因此某些类方法的实现与向量类不同。complexUDT 基类与其他两个类非常不同，但确实有一些共同的小代码段。但是当前的重构方法仍然会导致代码冗余。概念类中提到的所有方法都必须在每个实现中实现。

所以我的问题有两个。

  1. 我们如何使用 boost::mpl 来实现 Builder 设计模式？
  2. CRTP 在上面的例子中有什么帮助吗？
4

1 回答 1

1

如果我正确理解您想要做什么，这可能对您有用：

首先，每个容器都必须实现相同的接口。根据需要创建适配器（例如 ComplexUDT）：

struct AdapterUDT {
  typedef double const_reference;
  void push_back( double );
  private: ComplexUDT complexUDT;
};

虽然通常不建议这样做，但您可以将 dynamic_bitset 子类化以添加/修改功能。请注意，您不能多态地使用它，因为它缺少虚拟析构函数。确保它没有在其他地方使用。

struct AdapterBitset : dynamic_bitset<> { // not recommended
  typedef my_biterator iterator;
  AdapterBitset( int n ) : dynamic_bitset(n) {}
  iterator begin();
};

定义特征以将类型与容器相关联：

template<typename T> struct Trait {
  typedef vector<T> type;
};
template<> struct Trait<bool> {
  typedef dynamic_bitset<> type;
};

创建一个实现 Storage 接口的模板（减去容器）：

template<class T, class Derived> struct Base {
  typedef Base<T,Derived> base_t;
  typedef typename Trait<T>::type container_type;
  typedef typename container_type::const_reference const_reference;
  void append( const_reference value ) {
    // static polymorphism to access the standardized containers/adapters
    static_cast<Derived*>(this)->container.push_back(value);
  }
  // etc
};

由于您需要基于存储类型的构造函数，因此 Storage 模板必须管理实例化：

template<class T> struct Storage : Base<T,Storage<T>> {
  friend struct base_t;
  protected: container_type container;
};
// specialize for types with ctor arguments:
template<> struct Storage<bool> : Base<bool,Storage<bool>> {
  friend struct base_t;
  Storage( int bits ) : container(bits) {}
  protected: container_type container;
};

使用示例：

Storage<int> astore; // generic version uses default ctor
astore.append(314);
Storage<bool> bstore(7); // bool specialization requires an int
bstore.append(true);

这应该会减少大部分冗余代码。如果这不是您要查找的内容，我需要一个更具体的示例来说明您希望解决的问题。

于 2012-10-23T10:07:30.727 回答