// Feladat: keressük az első előfordulást...


    int t[] = { 1, 3, 5, ... };

    int *pi = find( t, t+sizeof(t)/sizeof(t[0]), 55);

    if ( pi )
    {
        *pi = 56;
    }



    // Egy nagyon specifikus find():


    int *find( int *begin, int *end, int x)
    {
        while ( begin != end )
        {
            if ( *begin == x )
            {
                return begin;
            }
            ++begin;
        }
        return 0;
    }



    // Általánosítsunk a típuson: int -> T


    template <typename T>
    T *find( T *begin, T *end, const T& x)
    {
        while ( begin != end )
        {
            if ( *begin == x )
            {
                return begin;
            }
            ++begin;
        }
        return 0;
    }



    // Általánosítsunk az adatszerkezeten: ++, *


    template <typename It, typename T>
    It find( It begin, It end, const T& x)
    {
        while ( begin != end )
        {
            if ( *begin == x )
            {
                return begin;
            }
            ++begin;
        }
        return end;
    }



    // Egységes használat: 


    int t[] = { 1, 3, 5, ... };

    int *pi = find( t, t+sizeof(t)/sizeof(t[0]), 55);

    if ( pi )
    {
        *pi = 56;
    }

    vector<int> v;
    v.push_back(1); v.push_back(3); v.push_back(5); ...

    vector<int>::iterator vi = find( v.begin(), v.end(), 55);

    if ( vi != v.end() )
    {
        *vi = 56;
    }

    list<double> l;
    l.push_back(1.1); l.push_back(3.3); l.push_back(5.5); ...

    list<double>::iterator li = find( l.begin(), l.end(), 55.55);

    if ( li != l.end() )
    {
        *li = 56.66;
    }



    // Konstans-biztosság:


    const int t[] = { 1, 3, 5, ... };

    const int *pi = find( t, t+sizeof(t)/sizeof(t[0]), 55);

    if ( pi )
    {
        // *pi = 56;    Syntax error
        cout << *pi;
    }

    vector<int> v;
    v.push_back(1); v.push_back(3); v.push_back(5); ...

    const list<double> cl( v.begin(), v.end());

    list<double>::const_iterator cli = find( cl.begin(), cl.end(), 55.55);

    if ( cli != cl.end() )
    {
        // *cli = 56.66;    Syntax error
        cout << *cli;
    }



    // Keressük meg a harmadik előfordulást:


    list<double> l; ...
    list<double>::iterator li;

    li = find( l.begin(), l.end(), 3.14);
    li = find( li, l.end(), 3.14);
    li = find( li, l.end(), 3.14);

    // vagy: 

    li = find(find(find(l.begin(),l.end(),3.14),l.end(),3.14),l.end(),3.14);



    // Keressük meg a harmadik elemet, amelyik kisebb 55-nél:


    template <typename It, typename Pred>
    It find_if( It begin, It end, Pred p)
    {
        while ( begin != end )
        {
            if ( p(*begin) )
            {
                return begin;
            }
            ++begin;
        }
        return end;
    }



    // Predikátum I. (nem túl jó):

    bool less55_3rd( int x)
    {
        static int cnt = 0;
        if ( x < 55 )
            ++cnt;
        return 3 == cnt;
    }


    // Használat:

    vector<int> v; ...

    vector<int>::iterator = find_if( v.begin(), v.end(), less55_3rd);



    // Predikátum II:

    struct less55_3rd
    {
        less55_3rd() : cnt(0) { }
        bool operator()(int x)
        {
            if ( x < 55 )
               ++cnt;
            return 3 == cnt;
        }
    private:
        int cnt;
    };


    // Használat:


    vector<int> v; ...

    less55_3rd  pp;
    vector<int>::iterator = find_if( v.begin(), v.end(), pp);

    // vagy:

    vector<int>::iterator = find_if( v.begin(), v.end(), less55_3rd());



    // Predikátum III.: általánosabban

    template <typename T>
    struct less_nth
    {
        less_nth( const T& t, int n) : t_(t), n_(n), cnt_(0) { }
        bool operator()(const T& t)
        {
            if ( t < t_ )
               ++cnt;
            return n_ == cnt;
        }
    private:
        T   t_;
        int n_;
        int cnt_;
    };


    // Használat:


    vector<int> v; ...

    vector<int>::iterator = find_if(v.begin(),v.end(),less_nth<int>(55,3));