Question

我想使用算法std::include来处理异构STL集合。在我的示例中，我想检查std::vector中是否包含std::map整数。

我想通过使用简单的模板化函数来解决这个问题;这是因为我想使用C ++模板参数推导来推断比较器函数的第一个参数是std :: pair vs int而另一种方式（std::include幕后调用Comp（a，b）和Comp（b，a））。

在我的代码下面，我想运行

    typedef std::map<int,std::string> dict;
    typedef std::vector<int> vect;

    int data[]={1,2,3,4};
    vect l(data,data+4);
    dict h;
    h.insert(dict::value_type(0,"ciccio"));
    h.insert(dict::value_type(1,"ciccio"));                  
    std::includes( h.begin(),h.end()
        , l.begin(), l.end(), is_my_less );

我尝试了以下内容，但它没有编译并说partial specialization is not allowed而且unresolved overloaded function type让我觉得我的功能有问题。您是否知道严格使用模板化函数是否可行？

    template<class T1,class T2,class T3>
    bool is_less_than_pair( const T1&a ,const T2& b ){
        return false;
    };

    template<class T1,class T>
    bool is_less_than_pair<
        T1
        , std::pair<T1,T>
        , T >( const T1&a, const std::pair<T1,T>& b ){
        return a<b.first;
    }

    template<class T1, class T>
    bool is_less_than_pair< 
        std::pair<T1,T>
        ,T1
        , T >( const std::pair<T1,T>& a, const T1& b ){
        return a.first<b;
    }

现在基于功能模板不能部分专业化的事实我试过像下面这样的函数重载但它没有用完，gcc再次告诉我unresolved overloaded function type。我能做的最好的是什么？

      template<class T1,class T2>
      bool is_less_than_pair( const std::pair<T1,T2>& a ,const T1& b ){
        return a.first<b;
      };
      template<class T1,class T2>
      bool is_less_than_pair( const T1& a ,const std::pair<T1,T2>& b ){
        return b.first<a;
      };

Answer 1

如果你受限于功能，没有。您不能使用重载函数，因为在将其传递给STL算法时将无法选择正确的重载。而且你不能部分专门化一个功能模板。

通过提供所有重载，可以使用函数对象完成。实际上，您将所有重载传递给STL算法，然后它会在调用时选择适当的重载。请注意，由于地图的值为std::pair<const int, string>&，因此在混合模式运算符的两侧使用相同的T1将不起作用，因为向量的迭代器正在转向int＆amp;，其中地图使用的是恒定。

struct my_less_than
{
   template <typename T1>
   bool operator()(const T1& lhs, const T1& rhs) const
   {
      return lhs < rhs;
   }

   template <typename T1, typename T2, typename T3>
   bool operator()(const T1& lhs, const std::pair<T2, T3>& rhs) const
   {
      return lhs < rhs.first;
   }

   template <typename T1, typename T2, typename T3 >
   bool operator()(const std::pair<T1, T2>& lhs, const T3& rhs) const
   {
      return lhs.first < rhs;
   }

   template <typename T1, typename T2, typename T3>
   bool operator()(const std::pair<T1, T2>& lhs, const std::pair<T1, T3>& rhs) const
   {
      return lhs.first < rhs.first;
   }
};

用法：

   std::includes( h.begin(),h.end()
        , l.begin(), l.end(), my_less_than() );

修改：示例http://ideone.com/JFIoy

通过使用专用函数对异构集合的STL算法

1 个答案: