C++ 基于专用函数的异构集合STL算法

我想使用算法

std:：include

来处理异构STL集合。在我的示例中，我想检查

std:：vector

的整数是否包含在

std:：map

中

我想通过使用一个简单的模板函数来解决这个问题；这是因为我想用C++模板参数推导来推断当比较器函数的第一个参数是STD:：对对int和另一种方式（<代码> STD:：包含幕后调用/COMP> 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 );

现在基于函数模板不能部分专门化的事实，我尝试了如下函数重载，但没有成功，gcc再次告诉我

未解析的重载函数类型

。我能做的最好的是什么

      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;
      };

模板
布尔值比成对值小（常数std:：成对&a，常数T1&b）{
返回a.first如果您仅限于函数，则返回否。您不能使用重载函数，因为在将其传递给STL算法时，它将无法选择正确的重载。并且您不能部分地专门化函数模板

可以通过提供所有重载来使用函数对象完成。实际上，您将把所有重载传递给STL算法，然后它将选择调用的适当重载。注意，由于映射的值是
std:：pair&
，因此在混合模式运算符的两侧使用相同的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;
   }
};

编辑：示例
如果您仅限于函数，则不可以。您不能使用重载函数，因为在将其传递给STL算法时，重载函数将无法选择正确的重载。并且您不能部分专门化函数模板

可以通过提供所有重载来使用函数对象完成。实际上，您将把所有重载传递给STL算法，然后它将选择调用的适当重载。注意，由于映射的值是
std:：pair&
，因此在混合模式运算符的两侧使用相同的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;
   }
};

编辑：示例
您不能部分专门化函数模板。@jrok。非常感谢，因为这个事实，我添加了另一个可能的解决方案，但它不起作用……您能帮忙吗？您不能部分专门化函数模板。@jrok。非常感谢，因为这个事实，我添加了另一个可能的解决方案，但它不起作用嗯……你能帮个忙吗？我想第四个重载应该是
const std:：pair&lhs，const std:：pair&rhs
——第二个类型没有使用，所以谁在乎它是否不同呢？@ildjarn：你说得对，我刚刚剪切并粘贴了它。我已经更新以匹配你的建议。我认为第四个重载应该是
const std:：pair&lhs，const st st std:：pair&rhs
——第二种类型没有使用，所以谁在乎它是否不同？@ildjarn:你说得对，我刚刚剪切并粘贴了它。我已经更新以符合你的建议
   std::includes( h.begin(),h.end()
        , l.begin(), l.end(), my_less_than() );