equal_to usage in C++ template class

Question

I am confused on how to use this method. I tried the following:

std::equal_to(T objA, T objB);

I get errors if I use it like this. However, I have seen countless examples that use it like this:

pairs1 = mismatch(v1.begin(), v1.end(), 
                  v2.begin(), 
                  equal_to<int>()); 

How is this method supposed to be used?

Sample Error:

prog.cpp: In function ‘int main()’:
prog.cpp:25:31: error: no matching function for call to ‘std::equal_to<int>::equal_to(std::vector<int>&, std::vector<int>&)’
  pairs1 = equal_to<int>(v2, v1)); 
                               ^
In file included from /usr/include/c++/5/string:48:0,
                 from /usr/include/c++/5/random:40,
                 from /usr/include/c++/5/bits/stl_algo.h:66,
                 from /usr/include/c++/5/algorithm:62,
                 from prog.cpp:2:
/usr/include/c++/5/bits/stl_function.h:352:12: note: candidate: constexpr std::equal_to<int>::equal_to()
     struct equal_to : public binary_function<_Tp, _Tp, bool>
            ^
/usr/include/c++/5/bits/stl_function.h:352:12: note:   candidate expects 0 arguments, 2 provided
/usr/include/c++/5/bits/stl_function.h:352:12: note: candidate: constexpr std::equal_to<int>::equal_to(const std::equal_to<int>&)
/usr/include/c++/5/bits/stl_function.h:352:12: note:   candidate expects 1 argument, 2 provided
/usr/include/c++/5/bits/stl_function.h:352:12: note: candidate: constexpr std::equal_to<int>::equal_to(std::equal_to<int>&&)
/usr/include/c++/5/bits/stl_function.h:352:12: note:   candidate expects 1 argument, 2 provided

Answer 1

equal_to is not a function, you cannot call it directly like one. It's a class that has the operator() defined which means that you need to create an object and call operator() on that object.

Possible implementation:

template <class T = void>
struct equal_to {
    constexpr bool operator()(const T& lhs, const T& rhs) const
    {
        return lhs == rhs;
    }
};

Usage example:

auto test()
{
    auto my_comp = equal_to<int>{};
    bool b1 =  my_comp(2, 3);

    // or create a temporary object and call it in one line:
    bool b2 = equal_to<int>{}(2, 3);
}

It also has a specialization that will deduce the arguments passed to operator() :

template <>
struct equal_to<void> {

    template <class T, class U>
    constexpr auto operator()(T&& lhs, U&& rhs) const
        -> decltype(std::forward<T>(lhs) == std::forward<U>(rhs))
    {
        return std::forward<T>(lhs) == std::forward<U>(rhs);
    }
};

auto test2()
{
    using namespace std::string_literals;
    auto my_comp = equal_to<>{};

    bool b1 = my_comp(2, 3);
    bool b2 = my_comp("one string"s, "another string"s);
}