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

class stateful_functor 
{
public:
    stateful_functor(int initial_state) : state_(initial_state) {}
    void operator()(int x)
    {
        // здесь какие-то действия, зависящие от state_
        if (state_)       --state_;
        else                ++state_;
    }
private:
    stateful_functor(const stateful_functor&);
    stateful_functor& operator=(const stateful_functor&);
    int state_;
};
//...
typedef std::vector<int> VI;
VI vi;
std::for_each(vi.begin(), vi.end(), stateful_functor(0) );

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

WH>А теперь в твою fibo_one начали передавать значения 1000, 999...1

int fibo(int n)
{
  if(n < 2) return 1;

  // Критическую секцию для потокобезопасности писать не стану. Обойдесса
  static map<int,int> fn;
  static int known = 0;

  if(n < known) return fn[n];
  int f = fibo(n-2) + fibo(n-1);
  known = n;
  fn[n] = f;
  return f;
}

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

void WINAPI enumSomething(params, callback) // в недрах библиотеки
{
  context (params);
  for(context.init(); context.okay(); context.next())
  {
    callback(context.result());
  }
}

//////////

HANDLE WINAPI begin_enumSomething(params)
{
  pcontext = new context(params);
  pcontext->init();
  return (HANDLE)pcontext;
}
bool next_enumSomething(HANDLE h, result& r)
{
  pcontext = (context*)h;
  if(!pcontext->okay()) return false;
  r = pcontext->result();
  return true;
}
void close_enumSomething(HANDLE h)
{
  delete (context*)h;
}

К>Результат вычисления чистой функции не зависит от количества прогонов

size_t fibo(size_t n)
{
    static std::vector<size_t> cache(2, 1);
    while(n>cache.size())
        cache.push_back(*(cache.end()-1)+*(cache.end()-2));
    return cache[n-1];
}

К>void WINAPI enumSomething(params, callback) // в недрах библиотеки
К>{
К>  context (params);
К>  for(context.init(); context.okay(); context.next())
К>  {
К>    callback(context.result());
К>  }
К>}

К>HANDLE WINAPI begin_enumSomething(params)
К>{
К>  pcontext = new context(params);
К>  pcontext->init();
К>  return (HANDLE)pcontext;
К>}

К>bool next_enumSomething(HANDLE h, result& r)
К>{
К>  pcontext = (context*)h;
К>  if(!pcontext->okay()) return false;
К>  r = pcontext->result();
К>  return true;
К>}

К>void close_enumSomething(HANDLE h)
К>{
К>  delete (context*)h;
К>}

/// XML sequence processor base class
template<typename Char>
struct processor
{
 virtual ~processor() {} //NOTE: may be not necessarily?
 /// Process sequence.
 /// @return True if processing complete.
 virtual bool operator()(Char ch) = 0;
 /// Result 
 typename xml::char_traits<Char>::string_type result;
};

/// Accumulate characters until terminator char doubled
template<typename Char>
class chars_accumulator2 : public processor<Char>
{
public:
 chars_accumulator2(Char terminator) : term_(terminator), num_terms_(0)
 {}
 bool operator()(Char ch)
 {
  if ( 2 == num_terms_ ) return false;
  num_terms_ = ( term_ == ch )? num_terms_ + 1 : 0;
  result.push_back(ch);
  return true;
 }
private:
 Char term_;
 size_t num_terms_;
};

/// Apply processor for each element in range while true.
/// @return  Iterator to next not applied element.
template<typename Char, typename InputIterator>
inline InputIterator apply_while(InputIterator first, InputIterator last, 
         processor<Char>& proc)
{
 for ( ; first != last; ++first )
  if ( !proc(*first) ) break;
 return first;
}

template<typename Char, typename InputIterator>
inline InputIterator parse_comment(InputIterator first, InputIterator last)
{
 // ...
 // parse comment body
 chars_accumulator2<Char> accum2(xml::char_traits<Char>::minus);
 first = apply_while(++first, last, accum2);
 first = check_end_tag<Char>(first, last);
 assert( accum2.result.size() >= 2 );
 // erase extra minuses
 accum2.result.resize( accum2.result.size() - 2 );
 handler.on_comment(accum2.result);
 return first;
}

struct Incr
{
   Incr(int x) : x_(x) {}
   void operator()(int& i) { i += x_; }
private:
   int x_;
};

Incr incr1(1), incr2(2);

PM>/// XML sequence processor base class
PM>template<typename Char>
PM>struct processor
PM>{
PM> virtual ~processor() {} //NOTE: may be not necessarily?
PM> /// Process sequence.
PM> /// @return True if processing complete.
PM> virtual bool operator()(Char ch) = 0;
PM> /// Result 
PM> typename xml::char_traits<Char>::string_type result;
PM>};

PM>/// Accumulate characters until terminator char doubled
PM>template<typename Char>
PM>class chars_accumulator2 : public processor<Char>
PM>{
PM>public:
PM> chars_accumulator2(Char terminator) : term_(terminator), num_terms_(0)
PM> {}
PM> bool operator()(Char ch)
PM> {
PM>  if ( 2 == num_terms_ ) return false;
PM>  num_terms_ = ( term_ == ch )? num_terms_ + 1 : 0;
PM>  result.push_back(ch);
PM>  return true;
PM> }
PM>private:
PM> Char term_;
PM> size_t num_terms_;
PM>};

PM>/// Apply processor for each element in range while true.
PM>/// @return  Iterator to next not applied element.
PM>template<typename Char, typename InputIterator>
PM>inline InputIterator apply_while(InputIterator first, InputIterator last, 
PM>         processor<Char>& proc)
PM>{
PM> for ( ; first != last; ++first )
PM>  if ( !proc(*first) ) break;
PM> return first;
PM>}

PM>template<typename Char, typename InputIterator>
PM>inline InputIterator parse_comment(InputIterator first, InputIterator last)
PM>{
PM> // ...
PM> // parse comment body
PM> chars_accumulator2<Char> accum2(xml::char_traits<Char>::minus);
PM> first = apply_while(++first, last, accum2);
PM> first = check_end_tag<Char>(first, last);
PM> assert( accum2.result.size() >= 2 );
PM> // erase extra minuses
PM> accum2.result.resize( accum2.result.size() - 2 );
PM> handler.on_comment(accum2.result);
PM> return first;
PM>}

 PM>> /// XML sequence processor base class
 PM>> template<typename Char>
 PM>> struct processor
 PM>> {
 PM>> };
 W>

 PM>> /// Accumulate characters until terminator char doubled
 PM>> template<typename Char>
 PM>> class chars_accumulator2 : public processor<Char>
 PM>> {
 PM>> };
 W>

/// Apply processor for each element in range while true.
/// @return  Iterator to next not applied element.
template<typename Char, typename InputIterator>
inline InputIterator apply_while(InputIterator first, InputIterator last, processor<Char>& proc);

template<typename Char, typename InputIterator, typename Functor>
inline InputIterator apply_while(InputIterator first, InputIterator last, Functor& proc);

template<typename Char, typename InputIterator, typename OutputIterator,  typename Functor>
inline InputIterator apply_while(InputIterator first, InputIterator last, OutputIterator dst, Functor& proc)
{
    for ( ; first != last!; ++first, ++dst)
    {
        if ( !proc(*first) ) break;
        *dst = ??? // здесь мы все равно должны дернуть proc, чтобы узнать результат его работы, кторого может и не быть
    }
    return first;
}

PM>Мне будет очень интересно узнать твое мнение об архитектуре как таковой, так и о реализации в частности.

#include "stdafx.h"

template<class input_iter_t>
struct xml_parser
{
    int deep;
    input_iter_t cur;
    input_iter_t end;
    void check(bool condition, const std::string& msg="unknown error.")
    {
        if(!condition)
            throw std::string(msg);
    }

    bool is_end()
    {
        return cur==end;
    }
    char get()
    {
        return *cur;
    }
    void next()
    {
        ++cur;
    }
    void skip_space()
    {
        while(!is_end()&&isspace(get()))
            next();
    }

    void tag()
    {
        check(!is_end());
        std::string open;
        while(!is_end()&&isalnum(get()))
        {
            open+=get();
            next();
        }
        check(!is_end()&&get()=='>');
        next();

        ++deep;
        body();
        --deep;

        check(!is_end()&&get()=='/');
        next();
        std::string close;
        while(!is_end()&&isalnum(get()))
        {
            close+=get();
            next();
        }
        check(!is_end()&&get()=='>');
        next();
        check(open==close);
    }

    void comment()
    {
        check(!is_end()&&get()=='!');    next();
        check(!is_end()&&get()=='-');    next();
        check(!is_end()&&get()=='-');    next();
        int count=0;
        while(!is_end())
        {
            count
                =(get()=='-')
                ?count+1 
                :0;
            next();
            if(count==2)
            {
                check(!is_end());
                if(get()=='>')
                    break;
                count=1;
            }
        }
        check(!is_end());
        next();
    }

    void body()
    {
        check(!is_end());
        while(true)
        {
            skip_space();
            if(cur==end)
            {
                if(deep==0)
                    return;
                check(false);
            }
            switch(get())
            {
            case '<':
                next();
                check(!is_end());
                switch(get())
                {
                    case '/':
                        return;
                    break;
                    case '!':
                        comment();
                    break;
                    default:
                        tag();
                    break;
                }
            break;
            default:
                check(false);
            break;
            }
        }
    }

    void parse_begin(input_iter_t _cur, input_iter_t _end)
    {
        deep=0;
        cur=_cur;
        end=_end;
        body();
    }
};
int main()
{
    std::string src=
        "    <asd>"
        "        <qwe>"
        "            <!---->"
        "            <!--"
        "        ->        qeqwed"
        "        <!-        sacsdf"
        "        --        <qwe>"
        "                </qwe>"
        "            ---->"
        "        </qwe>"
        "    </asd>"
        ;
    try
    {
        xml_parser<std::string::iterator> p;
        p.parse_begin(src.begin(), src.end());
    }
    catch(const std::string& msg)
    {
        std::cout<<msg<<std::endl;
    }
    return 0;
}

template <class ForwardIterator, class Predicate>
ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
Predicate pred) {
first = find_if(first, last, pred);
ForwardIterator next = first;
return first == last ? first : remove_copy_if(++next, last, first, pred);
}

template<typename Char>
class chars_accumulator2 : public processor<Char>
{
public:
chars_accumulator2(Char terminator, size_t& num_terms) : term_(terminator), num_terms_(num_terms)
{}
//....skip
Char term_;
size_t& num_terms_;
};

template<typename Char>
class chars_accumulator2 : public processor<Char>
{
public:
struct external_state
{
    external_state():num_terms(0){}
    size_t num_terms;
};
chars_accumulator2(Char terminator, external_state& estate) : term_(terminator), num_terms_(estate.num_terms)
{}
//....skip
Char term_;
size_t& num_terms_;
};