Реализация алгоритма find_firdt_not_of через другие алгоритмы

#include <iostream>
#include <algorithm>
#include <functional>
 
template <class ForwardIter1, class ForwardIter2>
ForwardIter1 find_first_not_of(ForwardIter1 start1, ForwardIter1 stop1, ForwardIter2 start2, ForwardIter2 stop2){
    ForwardIter1 i;
    for ( i = start1; i != stop1; ++i )
        if ( std::find(start2, stop2, *i) == stop2 )
            break;
    return i;
}
 
template <class ForwardIter1, class ForwardIter2, class BinPred>
ForwardIter1 find_first_not_of(ForwardIter1 start1, ForwardIter1 stop1, ForwardIter2 start2, ForwardIter2 stop2, BinPred bp){
    ForwardIter1 i;
    for ( i = start1; i != stop1; ++i )
        if ( std::find_if(start2, stop2, std::bind1st(bp,*i)) == stop2 )
            break;
    return i;
}
 
 
int main(void){
    const int SIZE = 5;
    int arr1[SIZE] = { 1, 2, 3, 11, 5 };
    int arr2[SIZE] = { 6, 7, 8, 9, 10 };
    int * ptr;
    
    if ( ( ptr = (int*)find_first_not_of(arr1, arr1 + SIZE, arr2, arr2 + SIZE, std::less<int>()) ) == arr1 + SIZE )
        std::cout << "all elements from arr1 less then elements from arr2" << std::endl;
    else 
        std::cout << "First element from arr1 that is bigger elements in arr2 is " << *ptr << std::endl;
    
    return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
 
template <typename Iter, typename Pred>
class NotIn
{
    Iter b;
    Iter e;
    Pred p;
public:
    NotIn(Iter const& start, Iter const& stop, Pred const& pred) :
        b(start), e(stop), p(pred) {}
    template <typename T>
    bool operator() (T const& v) const
        { return std::find_if(b, e, std::bind2nd(p, v)) == e;   }
};
 
template <typename Iter1, typename Iter2, typename Pred>
Iter1 find_first_not_of(Iter1 start1, Iter1 stop1, Iter2 start2, Iter2 stop2, Pred const& p)
{
    return std::find_if(start1, stop1, NotIn<Iter2, Pred>(start2, stop2, p));
}
 
class MyInt
{
    int iv;
public:
    MyInt() : iv() {}
    explicit MyInt(int v) : iv(v) {}
    MyInt(MyInt const& mi) : iv(mi.iv) {}
    bool operator == (int v) const { return iv == v; }
};
 
struct MyIntEqualToInt : public std::binary_function<MyInt, int, bool>
{
    bool operator() (MyInt const& mi, int v) const
        { return mi == v; }
};
 
int main(void){
    const int SIZE = 5;
    int arr1[SIZE] = { 1, 2, 3, 6, 5 };
    std::vector<MyInt> arr2;
    arr2.push_back(MyInt(1));
    arr2.push_back(MyInt(2));
    arr2.push_back(MyInt(3));
    arr2.push_back(MyInt(4));
    arr2.push_back(MyInt(5));
    int * ptr;
 
    if ( ( ptr = (int*)find_first_not_of(arr1, arr1 + SIZE,
                    arr2.begin(), arr2.end(),
                    MyIntEqualToInt()) 
         ) == arr1 + SIZE )
        std::cout << "all elements from arr1 found in arr2" << std::endl;
    else 
        std::cout << "First element from arr1 that not found in arr2 is " << *ptr << std::endl;
 
    return 0;
}

std::find_first_of( first1, last1, first2, last2, &f );

find_first_not_of( first1, last1, first2, last2, &f );