Concept : La bibliothèque standard C++ (STL) propose des objets fonctionnels prédéfinis

Catégories :

• Foncteurs arithmétiques
• Foncteurs relationnels
• Foncteurs logiques

Utilisation :

• Ces objets fonctionnels s'utilisent de la même manière que des fonctions classiques
• Pour utiliser les objets fonctionnels intégrés, inclure l'en-tête #include <functional>

1. Foncteurs arithmétiques

Descripiton :

• Réalisent des opérations arithmétiques de base
• negate est un opérateur unaire, les autres sont binaires

Prototypes :

• template<class T> T plus <T> // Addition
• template<class T> T minus<T> // Soustraction
• template<class T> T multiplies<T> // Multiplication
• template<class T> T divides<T> // Division
• template<class T> T modulus<T> // Modulo
• template<class T> T negate<T> // Négation

Exemple de code :

#include <iostream>
#include <functional>

using namespace std;

void demonstrationUnaire() {
    // Foncteur unaire pour la négation
    negate<int> operateurNegation;
    cout << "Résultat de la négation : " << operateurNegation(25) << endl;
}

void demonstrationBinaire() {
    // Foncteur binaire pour l'addition
    plus<double> operateurAddition;
    cout << "Résultat de l'addition : " << operateurAddition(7.5, 3.2) << endl;
}

int main() {
    // Affiche : -24 10.7
    demonstrationUnaire();
    demonstrationBinaire();
    return 0;
}

2. Foncteurs relationnels

Description :

• Effectuent des comparaisons relationnelles

Prototypes :

• template<class T> bool equal_to<T> // Égal à
• template<class T> bool not_equal_to<T> // Différent de
• template<class T> bool greater<T> // Supérieur à
• template<class T> greater_equal<T> // Supérieur ou égal à
• template<class T> less<T> // Inférieur à
• template<class T> less_equal<T> // Inférieur ou égal à

Exemple de code :

#include <iostream>
#include <vector>
#include <functional>

using namespace std;

// Affiche les éléments d'un vecteur
void afficherVecteur(const vector<int>& vecteur) {
    for (const auto& element : vecteur) {
        cout << element << " ";
    }
    cout << endl;
}

// Classe de comparaison personnalisée
class ComparaisonInverse {
public:
    bool operator()(int val1, int val2) {
        return val1 < val2;
    }
};

void triDemonstration() {
    vector<int> donnees = {60, 15, 35, 5, 45};
    
    cout << "Vecteur initial : ";
    afficherVecteur(donnees);

    // Tri croissant
    sort(donnees.begin(), donnees.end());
    cout << "Tri croissant : ";
    afficherVecteur(donnees);

    // Tri décroissant avec comparateur personnalisé
    sort(donnees.begin(), donnees.end(), ComparaisonInverse());
    cout << "Tri décroissant (personnalisé) : ";
    afficherVecteur(donnees);

    // Tri décroissant avec foncteur intégré
    sort(donnees.begin(), donnees.end(), greater<int>());
    cout << "Tri décroissant (intégré) : ";
    afficherVecteur(donnees);
}

int main() {
    triDemonstration();
    return 0;
}

Résultat :

60 15 35 5 45 5 15 35 60 60 35 15 5 60 35 15 5

3. Foncterus logiques

Description :

• template<class T> bool logical_and<T> // ET logique
• template<class T> bool logical_or<T> // OU logique
• template<class T> bool logical_not<T> // NON logique

Exemple de code :

#include <iostream>
#include <vector>
#include <functional>

using namespace std;

// Affiche les éléments d'un vecteur de booléens
void afficherBooleans(const vector<bool>& booleans) {
    for (const auto& valeur : booleans) {
        cout << valeur << " ";
    }
    cout << endl;
}

void manipulationLogique() {
    vector<bool> valeurs = {true, false, true, false, true};
    
    cout << "Valeurs originales : ";
    afficherBooleans(valeurs);

    // Utilisation du foncteur logique NOT
    vector<bool> valeursInverties;
    valeursInverties.resize(valeurs.size());
    transform(valeurs.begin(), valeurs.end(), valeursInverties.begin(), logical_not<bool>());

    cout << "Valeurs inversées : ";
    afficherBooleans(valeursInverties);

    // Utilisation du foncteur logique AND
    vector<bool> resultatEt;
    resultatEt.resize(valeurs.size());
    transform(valeurs.begin(), valeurs.end(), valeursInverties.begin(), resultatEt.begin(), logical_and<bool>());

    cout << "Résultat ET : ";
    afficherBooleans(resultatEt);
}

int main() {
    manipulationLogique();
    return 0;
}

Résultat :

1 0 1 0 1 0 1 0 1 0 0 0 0 0 0