Dans l’exercice précédent, nous avons signalé que nous avons perdu en généralité par rapport à la technique de passage de pointeur de fonction, puisque la fonction moulinette() est limitée à un seul type de traitement.

Nous allons maintenant lui rendre sa généralité.

Pour mettre la chaîne en majuscules par exemple, il faut commencer par écrire la nouvelle classe ToUpper, et y surcharger l’opérateur () adéquat.

Pour que la fonction moulinette() puisse mettre la chaîne en majuscules ou en minuscules (ou effectuer toute autre transformation), il faut utiliser le polymorphisme.

Travail à effectuer

Créer le projet FunctorAbstrait.

Dans votre fichier main.cpp copier le fichier TestFunctorAbstrait.cpp

/**
 *
 * @file    TestFunctorAbstrait.cpp
 *
 * @authors M. Laporte, D. Mathieu
 *
 * @date    27/04/2010
 *
 * @version V1.0
 *
 * @brief   functor abstrait
 *
 **/
#include <string>
#include <iostream>
#include <cctype>  // ispunct(), islower(), isalpha()
                   // tolower(), toupper()
#include <cassert>

using namespace std;

namespace 
{
    class ToLower
    {
      public :
        virtual ~ToLower (void) {}
        virtual int operator () (int caract) const
        {
            return tolower (caract);

        } // operateur()

    }; // CToLower

    string & moulinette (string & str, const ToLower & transf)
    {
        for (string::size_type i (str.size ()); i--; )
            str [i] = transf (str [i]);

        return str;

    } // moulinette()

    void testFunctor (void)
    {
        cout << "Functor abstrait : ";

        string ligne     ("azert:;,.?GFDSQ");
        string minusc    ("azert:;,.?gfdsq");
        string majusc    ("AZERT:;,.?GFDSQ");
        string sansPunct ("AZERT     GFDSQ");

        // ToDo

        assert (minusc    == moulinette (ligne, ...));
        assert (majusc    == moulinette (ligne, ...));
        assert (sansPunct == moulinette (ligne, ...));

        cout << "OK\n";

    } // testFunctor ()

} // namespace anonyme

int main (void)
{
    /*      */    testFunctor ();     /*           */

    return 0;

} // main()

Dans l’espace de noms anonyme, ajoutez-lui la classe abstraite ITraitCar dont l’unique fonction-membre abstraite a le même profil que tolower(), toupper(), etc.

N’oubliez pas son destructeur virtuel !

Faites dériver publiquement la classe ToLower de ITraitCar.

Sur le même modèle, écrivez les nouvelles classes ToUpper et IgnPunct qui transforment respectivement les minuscules en majuscules et les caractères de ponctuation en espaces.

Modifiez le type du second paramètre de moulinette() en conséquence.

Le tour est joué !

Dans la fonction testFunctor (), complétez les instructions assert().

Compilez et testez.