template<class InputIterator, class Predicate> InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);

InputIterator& tmp=...

 Matrix a;
 Matrix b;
 Matrix c;

 Matrix d = std::find_if(a, b, [&c](const Matrix& m) { return det(m * с) == 1; }

InputIterator& tmp;

InputIterator& tmp = ...;

BFE>InputIterator& tmp = ...;
BFE>

template<class InputIterator, class Predicate> InputIterator find_if(InputIterator first, InputIterator last, Predicate pred);

find_if<std::vector<int>::iterator&,..., Con> find_if();

template<> struct std::iterator_traits<std::vector<int>::iterator&> {
typedef std::ptrdiff_t difference_type;
typedef int value_type;
typedef int* pointer;
typedef int& reference;
typedef std::input_iterator_tag iterator_category;
};

template <typename T>
T func(...);

std::vector<int>::iterator it = arr.begin();
std::vector<int>::iterator itEnd = arr.end();
auto oFn = [](const int& n) { return 2 <= n; };
if ( std::find_if<std::vector<int>::iterator&, decltype(oFn)>(it, itEnd, oFn) != itEnd )
{
*it = 5;
}

auto oFn = [](const int& n) { return 2 <= n; };
std::vector<int>::iterator itEnd = arr.end();
std::vector<int>::iterator it= std::find_if(arr.begin(), itEnd, oFn);
if(it!=itEnd)
{
*it=5;
};

template< class T >
class Test
{
public:
   Test( const T& t ) : t_(t){}
   T getT() const {
      return t_;
   }
private:
   T t_;
};

I>std::vector<int> test = {1,2,6,7};
I>std::find_if(std::begin(test), std::end(test), [](int& current){
I>   if (current >= 2)
I>   {
I>      current = 5;
I>      return true;
I>   }
I>   return false;
I>});
I>

    std::vector<int> test = {1,2,6,7};
    for(auto& current : test)
    {
       if ( 2 <= current )
       {
          current = 5;
          break;
       }
    };

  /**
   *  @brief Find the first element in a sequence for which a
   *         predicate is true.
   *  @ingroup non_mutating_algorithms
   *  @param  __first  An input iterator.
   *  @param  __last   An input iterator.
   *  @param  __pred   A predicate.
   *  @return   The first iterator @c i in the range @p [__first,__last)
   *  such that @p __pred(*i) is true, or @p __last if no such iterator exists.
  */
  template<typename _InputIterator, typename _Predicate>
    inline _InputIterator
    find_if(_InputIterator __first, _InputIterator __last,
        _Predicate __pred)
    {
      // concept requirements
      __glibcxx_function_requires(_InputIteratorConcept<_InputIterator>)
      __glibcxx_function_requires(_UnaryPredicateConcept<_Predicate,
          typename iterator_traits<_InputIterator>::value_type>)
      __glibcxx_requires_valid_range(__first, __last);
      return std::__find_if(__first, __last, __pred,
                std::__iterator_category(__first));
    }

[ Example: Consider the following code:
class X {
public:
X(int);
X(const X&);
X& operator=(const X&);
~X();
};
class Y {
public:
Y(int);
Y(Y&&);
~Y();
};
X f(X);
Y g(Y);
void h() {
X a(1);
X b = f(X(2));
Y c = g(Y(3));
a = f(a);
};
An implementation might use a temporary in which to construct X(2) before passing it to f() using X’s
copy constructor; alternatively, X(2) might be constructed in the space used to hold the argument. Likewise,
an implementation might use a temporary in which to construct Y(3) before passing it to g() using Y’s
move constructor; alternatively, Y(3) might be constructed in the space used to hold the argument. Also,
a temporary might be used to hold the result of f(X(2)) before copying it to b using X’s copy constructor;
alternatively, f()’s result might be constructed in b. Likewise, a temporary might be used to hold the result
of g(Y(3)) before moving it to c using Y’s move constructor; alternatively, g()’s result might be constructed
in c. On the other hand, the expression a=f(a) requires a temporary for the result of f(a), which is then
assigned to a. — end example ]

BFE>    std::vector<int> arr;

BFE>    arr.push_back(0); arr.push_back(1); arr.push_back(2);

BFE>    std::vector<int>::iterator it    = arr.begin();
BFE>    std::vector<int>::iterator itEnd = arr.end();

BFE>    auto oFn = [](const int& n) { return 2 <= n; };

BFE>    if ( std::find_if<std::vector<int>::iterator&, decltype(oFn)>(it, itEnd, oFn) != itEnd )
BFE>    {
BFE>        *it = 5;
BFE>    }
BFE>

template<class It>
It foo(It i)
{
  ++i; // с этого момента экземпляр It, остававшийся в вызывающей стороне, условно-невалиден
  It j = i;
  ++j; // с этого момента i условно-невалиден
  return j;
}

foo(istream_iterator<int>(cin));

vector<int> arr(100);
vector<int>::iterator i = arr.begin();
i = foo(i);
foo<vector<int>::iterator&>(i);

template<class It>
It foo(It i, It end)
{
  It j = i;
  if(j != end)
  {
    ++j;
    assert(i != j); // если It чистый input iterator, то сравнивать i больше нельзя
    if(j != end) // а вот end - сколько угодно
    {
      ++j;
      assert( distance(i,j)==2 ); // если It чистый input, то использовать его в distance бессмысленно и вредно
    }
  }
  return j;
}

template<class It>
It middle(It i, It end)
{
  advance(i,
    distance(i,end)/2 // внутри distance мы изменили локальную копию i
  ); // поэтому передаваемая в advance ссылка должна быть на валидный итератор
  return i;
}

if( (it = find_if(it,itEnd,oFn)) != itEnd )
  .....

template<class It, class V>
bool skip_unequal(It& it, It end, V const& v) { it = find(it,end,v); return it != end; }

template<class It, class Pred>
bool skip_unless(It& it, It end, Pred pred) { it = find_if(it,end,pred); return it != end; }