Exo 1 P00

#include <iostream>
#include <vector>

using namespace std;
namespace  {

    class Pers /* : public IEditable */
    {
        string   myNom;
        unsigned myAge;

    public :
        Pers (const string & nom, unsigned age)
            : myNom (nom), myAge (age) {}

        const string & getNom (void) const noexcept { return myNom; }
        unsigned       getAge (void) const noexcept { return myAge; }

    private :
        ostream & display (ostream & os)  const
        {
            return os << getAge () << " - " << getNom ();

        } // display()

    public :    // ajouté pour faciliter les essais

        friend ostream & operator << (ostream & os, const Pers & p)
        {
            return p.display (os);
        }

    }; // Pers

    template <typename T>
    class ILessThanGen
    {
    public :
        virtual ~ILessThanGen (void) {}
        virtual bool operator () (const T &, const T &) const = 0;
    }; // ILessThanGen

    class TriParAgeAsc : public ILessThanGen <Pers>
    {
    public:
        virtual ~TriParAgeAsc() {}
        virtual bool operator() (const Pers & p1, const Pers & p2) const {return p1.getAge() < p2.getAge();}

    };//TriParAgeAdc

    class TriParNomDesc : public ILessThanGen <Pers>
    {
    public:
        virtual ~TriParNomDesc() {}
        virtual bool operator() (const Pers & p1, const Pers & p2) const {return p1.getNom() > p2.getNom();}

    };//TriParNomDesc



}



template <typename iter_t, typename T>
iter_t partitionnement (const iter_t & first, const iter_t & last, const ILessThanGen <T> & comparateur)
{
    bool isUp = true;
    iter_t pivot;
    iter_t courant;
    int incr;
    pivot = first;
    courant = last;
    incr = -1;
    while (pivot != courant) {
        if(((!isUp) && comparateur(*pivot, *courant)) || (isUp && comparateur(*courant, *pivot)))
        {
            swap(*pivot, *courant);
            swap(pivot, courant);
            isUp = !(isUp);
            incr = -incr;
        }
        courant = courant + incr;
    }
    return pivot;
}

template <typename iter_t, typename T>
void quickSort (const iter_t & beg, const iter_t & end, const ILessThanGen <T> & comparateur)
{
    if (beg < end)
    {
        iter_t pos;
        pos = partitionnement (beg, end - 1, comparateur);
        quickSort(beg, pos, comparateur);
        quickSort(pos + 1, end, comparateur);
    }
}



void functorSort (void)
{
    cout << "FunctorSort : \n";

    typedef vector <Pers> CVPers;

    CVPers vPers;

    vPers.push_back ( Pers ("Charlotte", 21));
    vPers.push_back ( Pers ("Alfred",    12));
    vPers.push_back ( Pers ("Jean",      42));
    vPers.push_back ( Pers ("Noemie",    11));
    vPers.push_back ( Pers ("Berthe",    99));
    vPers.push_back ( Pers ("Agathe",    29));
    vPers.push_back ( Pers ("Sylvain",   42));
    vPers.push_back ( Pers ("Pierre",    75));

    cout << "\nTri par age croissant\n\n";

    quickSort (vPers.begin (), vPers.end (), TriParAgeAsc ());

    for (const Pers & personne : vPers)
        cout << personne << '\n';

    cout << "\nTri par nom decroissant\n\n";

    quickSort (vPers.begin (), vPers.end (), TriParNomDesc ());

    for (const Pers & personne : vPers)
        cout << personne << '\n';

} // functorSort()




int main()
{
    cout << "Hello World!" << endl;
    functorSort();
    return 0;
}