class func
{
   int n_;
public:
   func(int n) : n_(n) {}
   bool operator() (int n) { return n == n_; }
};

...

func functor;

int fibonacci()
{
    static int x1=1;
    static int x2=1;
    int x3=x1+x2;
    x1=x2;
    x2=x3;
    retunr x3;
}

W> Функтор с сотоянием? Чему ты народ учишь...

 W> int fibonacci()
 W> {
 W>  static int x1=1;
 W>  static int x2=1;
 W>  int x3=x1+x2;
 W>  x1=x2;
 W>  x2=x3;
 W>  retunr x3;
 W> }
 W>

/// Accumulate characters until terminator char doubled
class chars_accumulator2
{
public:
 chars_accumulator2(char terminator) : term_(terminator), num_terms_(0) {}
 bool operator()(char ch)
 {
  if ( 2 == num_terms_ ) 
  {
    result.erase( result.end()-2, result.end() );
    return false;
  }
  num_terms_ = ( term_ == ch )? num_terms_ + 1 : 0;
  result.push_back(ch);
  return true;
 }
 std::string result;
private:
 char term_;
 size_t num_terms_;
};

...
std::string s("blablazzbla");
chars_accumulator2 camm2('z');
for (std::string::iterator it = s.begin(); it != s.end(); ++it)
{
    if ( !camm2(*it) ) break;
}

assert ( camm2.result == "blabla");

WH>Функтор с сотоянием? Чему ты народ учишь...

class in_range
{
   int begin_, end_;
public:
   in_range(int begin, int end) : begin_(begin), end_(end) {}
   bool operator () (int n) { return n >= begin_ && n < end; }
};

WH>Функтор с сотоянием? Чему ты народ учишь...

int fibo(int n)
{
  int f;
  ... вычисляем ...

  cout << "F(" << n << ")" << f << endl; // побочный эффект
  return f;
}

int fibo_once(int n)
{
  static map<int,int> fn;
  map<int,int>::const_iterator it = fn.find(n);
  if(it == fn.end())
  {
    int f = fibo(n);
    fn[n] = f; // еще один побочный эффект
    return f;
  }
  else return it->second;
}

WH>Функтор с сотоянием? Чему ты народ учишь...

WH>int fibonacci()
...
WH>

int fibonacci()
{
    static int x1 = 1;
    static int x2 = 1;
    int x3 = x1 + x2;
    x1 = x2;
    x2 = x3;
    return x3;
}

struct fibo
{
    int x1, x2;
    
    fibo() : x1(1), x2(1)
    {
    }
    
    int operator()()
    {
        int x3 = x1 + x2;
        x1 = x2;
        x2 = x3;
        return x3;
    }
};

int main(int argc, char* argv[])
{
    std::generate_n(std::ostream_iterator<int>(std::cout, "\n"), 5, fibonacci);
    std::generate_n(std::ostream_iterator<int>(std::cout, "\n"), 5, fibonacci);
    
    std::cout << std::endl;
    
    std::generate_n(std::ostream_iterator<int>(std::cout, "\n"), 5, fibo());
    std::generate_n(std::ostream_iterator<int>(std::cout, "\n"), 5, fibo());
    
    return 0;
}

PM>Извиняюсь, что влез в дискуссию, но я бы не стал так категорично утверждать, что функтор-класс с состоянием полный отстой

template
    <class input_iter
    ,class output_iter
    >
void repeat_until_terminator_doubled
    (input_iter begin
    ,input_iter end
    ,output_iter out
    ,typename std::iterator_traits<input_iter>::value_type terminator
    )
{
    typedef typename std::iterator_traits<input_iter>::value_type value_type;
    if(begin==end)return;
    value_type val[2];
    bool flag=false;//Используем свойства bool'ов false==0 true==1
    val[flag]=*begin;
    while(true)
    {
        ++begin;
        if(begin==end)
        {
            *out=val[flag];
            return;
        }
        flag=!flag;
        val[flag]=*begin;
        if(val[0]==val[1])
            return;
        *out=val[!flag];
        ++out;
    }
};

    std::string str("asdasfzasdzasfdzzaas");
    std::string res;
    repeat_until_terminator_doubled(str.begin(), str.end(), std::back_inserter(res), 'z');

    repeat_until_terminator_doubled
        (std::istream_iterator<char>(std::cin)
        ,std::istream_iterator<char>()
        ,std::ostream_iterator<char>(std::cout)
        ,'z'
        );

        if(val[0]==val[1])
            return;

        if(val[0]==terminator&&val[1]==terminator)
            return;

К>int fibo(int n)
К>{
К>  int f;
К>  ... вычисляем ...

К>  cout << "F(" << n << ")" << f << endl; // побочный эффект
К>  return f;
К>}
К>

К>int fibo_once(int n)
К>{
К>  static map<int,int> fn;
К>  map<int,int>::const_iterator it = fn.find(n);
К>  if(it == fn.end())
К>  {
К>    int f = fibo(n);
К>    fn[n] = f; // еще один побочный эффект
К>    return f;
К>  }
К>  else return it->second;
К>}
К>

    std::for_each
        (find_file_iterator("c:\\*.*")
        ,find_file_iterator()
        ,print_file_info
        );

B>>Думаю, ты изменишь свое мнение о функторах с сотоянием.

struct less_dist : std::binary_function<bool, point2, point2>
{
    explicit less_dist( const point2& base ) : m_base( base ) {}
    bool operator()( const point2& p0, const point2& p1 )
    {
        return sqr_dist( m_base, p0 ) < sqr_dist( m_base, p1 );
    }
private:
    const point2 m_base;
};
...
// сортируем элементы контейнера по расстоянию от точки
std::sort( v.begin(), v.end(), less_dist( point2(0, 0) ) );