0

我想使用算法std::include来处理异构 STL 集合。在我的示例中，我想检查 a std::vectorof integer 是否包含在 a 中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;
    }

现在基于函数模板不能部分专门化的事实，我尝试了如下所示的函数重载，但没有成功，gccunresolved 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;
      };
4

1 回答 1

4

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

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

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

于 2012-05-14T20:23:46.117 回答