c++ - 为提供不同接口(interface)的容器包装容器

Question

我想为 STL 容器创建通用的“包装器”，例如:

template<template <typename, typename...> class Container = std::vector >
class ContainerWrapper{
  add();
  size();
  find();
  resize();
  sort(); 
  /**/
}

+迭代器。我希望成员函数具有不同的实现，具体取决于 Container 提供的方法。 C++ 模板系统足以创建这个吗？这是否可能，仅使用标准(不提升，不干扰预处理器)？

我知道如何以困难的方式做到这一点——为每个 STL 容器编写模板特化。但我希望它也能与其他容器一起使用，而且我正在寻找更通用的方法来做到这一点。

此外，这里有什么更好的地方？继承 Container 还是将 Container 作为组件？

Answer 1

前段时间我为我的一个项目开发了类似的东西。

我已经提取了一个完整的工作示例(原始代码更复杂)来展示如何使用方法 addVal()(调用 push_back()， push()、insert() 或 push_front()) 向包装容器添加值。

此代码适用于(如果我没记错的话)std::vector、std::set、std::multiset、std::unordered_set, std::unordered_multiset, std::deque, std::queue, std::priority_queue、std::forward_list 和 std::stack。

其他容器(例如 std::array)可能需要对 cntWrp 进行不同的特化。

我不想解释每一行代码，但如果您有任何问题，我可以尝试回复(或者，如果您愿意，我可以给您我的 github 项目的链接)。

例子

#include <set>
#include <vector>
#include <iostream>
#include <stdexcept>
#include <type_traits>

class emptyClass
 { };

template <typename ... Ts>
struct funcType;

template <typename T, typename ... Ts>
struct funcType<T, Ts...>
 { using type
      = typename std::conditional<T::result,
         typename T::type, typename funcType<Ts...>::type>::type; };

template <>
struct funcType<>
 { using type = emptyClass; };


#define methodCheck_1(meth)                            \
                                                       \
   class helpMeth_1_##meth {};                         \
                                                       \
   template <typename T, typename A>                   \
   struct isWithMethod_1_##meth                        \
    {                                                  \
      template<typename U>                             \
      static decltype(U().meth(A())) func (U*);        \
                                                       \
      template<typename U>                             \
      static emptyClass func (...);                    \
                                                       \
      static const bool result                         \
         = ! std::is_same<emptyClass,                  \
                decltype(func<T>(nullptr))>::value;    \
                                                       \
      using  type = helpMeth_1_##meth;                 \
    }

methodCheck_1(insert);
methodCheck_1(push);
methodCheck_1(push_back);
methodCheck_1(push_front);

template <typename>
class cntWrp;

template <template <typename ...> class C, typename X, typename ... Xs>
class cntWrp< C<X, Xs...> >
 {
   private:

      using addModeType = typename funcType<
         isWithMethod_1_push_back<C<X, Xs...>, X>,
         isWithMethod_1_insert<C<X, Xs...>, X>,
         isWithMethod_1_push<C<X, Xs...>, X>,
         isWithMethod_1_push_front<C<X, Xs...>, X>>::type;

      static constexpr addModeType  addMode {};

      void addVal (X const & x, helpMeth_1_push_back const)
       { val.push_back(x); }

      void addVal (X const & x, helpMeth_1_push const)
       { val.push(x); }

      void addVal (X const & x, helpMeth_1_insert const)
       { val.insert(x); }

      void addVal (X const & x, helpMeth_1_push_front const)
       { val.push_front(x); }

      void addVal (X const & x, emptyClass const)
       { throw std::runtime_error("cntWr<>::addVal without mode"); }

   public:

      C<X, Xs...> val {};

      cntWrp ()
       { }

      cntWrp (C<X, Xs...> const & v0) : val { v0 }
       { }

      void addVal (X const & x)
       { addVal(x, addMode); }
 };

int main ()
 {
   cntWrp<std::set<int>>  csi;

   csi.addVal(2);
   csi.addVal(7);
   csi.addVal(5);

   std::cout << "set:" << std::endl;

   for ( auto const elem : csi.val )
      std::cout << elem << std::endl;

   cntWrp<std::vector<int>> cvi;

   cvi.addVal(2);
   cvi.addVal(7);
   cvi.addVal(5);

   std::cout << "vector:" << std::endl;

   for ( auto const elem : cvi.val )
      std::cout << elem << std::endl;
 }