Introduction à la surcharge d'opérateurs

La surcharge d'opérateurs en C++ permet de redéfinir le comportement des opérateurs standards afin qu'ils puissent interagir avec des types de données définis par l'utilisateur. Cette fonctionnalité améliore considérablement la lisibilité du code en permettant d'utiliser une syntaxe mathématique ou logique naturelle pour des objets complexes.

1. Surcharge de l'opérateur d'addition (+)

L'opérateur d'addition peut être surchargé pour combiner deux instances d'une classe personnalisée. Cette opération peut être implémentée soit en tant que méthode membre, soit en tant que fonction globale.

Implémentation via méthode membre

Lorsque l'opérateur est surchargé en tant que méthode membre, l'objet appelant est implicitement passé via le pointeur this.

class Vector2D {
public:
    float x, y;

    Vector2D(float xVal = 0.0f, float yVal = 0.0f) : x(xVal), y(yVal) {}

    // Surcharge de l'opérateur + en tant que méthode membre
    Vector2D operator+(const Vector2D& other) const {
        return Vector2D(this->x + other.x, this->y + other.y);
    }
};

void testMemberAddition() {
    Vector2D v1(2.0f, 3.0f);
    Vector2D v2(4.0f, 5.0f);
    
    // Appel implicite de l'opérateur surchargé
    Vector2D v3 = v1 + v2; 
    std::cout << "Résultat X: " << v3.x << ", Y: " << v3.y << std::endl;
}

Implémentation via fonction globale

Une fonction globale est particulièrement utile lorsque vous souhaitez surcharger l'opérateur pour des types mixtes, ou lorsque l'opérande gauche n'est pas une instance de votre classe.

class Vector2D {
public:
    float x, y;
    Vector2D(float xVal = 0.0f, float yVal = 0.0f) : x(xVal), y(yVal) {}
};

// Surcharge globale pour ajouter un scalaire à un vecteur
Vector2D operator+(const Vector2D& vec, float scalar) {
    return Vector2D(vec.x + scalar, vec.y + scalar);
}

void testGlobalAddition() {
    Vector2D v1(2.0f, 3.0f);
    Vector2D v2 = v1 + 10.0f;
    std::cout << "Résultat X: " << v2.x << ", Y: " << v2.y << std::endl;
}

Note importante : Il est impossible de modifier le comportement des opérateurs pour les types de données intégrés au langage. De plus, la surcharge doit rester cohérente avec la sémantique originale de l'opérateur pour éviter toute confusion.

2. Surcharge de l'opérateur d'insertion de flux (<<)

Pour afficher directement des objets personnalisés avec std::cout, il est nécessaire de surcharger l'opérateur de décalage vers la gauche. Puisque l'opérande gauche doit être le flux de sortie (std::ostream), cette surcharge doit obligatoirement être une fonction globale, souvent déclarée comme fonction amie (friend) pour accéder aux membres privés.

class SensorReading {
    friend std::ostream& operator<<(std::ostream& os, const SensorReading& reading);

private:
    double temperature;
    double humidity;

public:
    SensorReading(double temp, double hum) : temperature(temp), humidity(hum) {}
};

// Retourne une référence pour permettre le chaînage des appels
std::ostream& operator<<(std::ostream& os, const SensorReading& reading) {
    os << "Température: " << reading.temperature << "°C, Humidité: " << reading.humidity << "%";
    return os;
}

void testStreamInsertion() {
    SensorReading data(22.5, 45.0);
    std::cout << data << " | Données valides." << std::endl;
}

3. Surcharge des opérateurs d'incrémentation (++ et --)

Les opérateurs d'incrémentation préfixée et postfixée possèdent des sémantiques différentes. Le pré-incrément modifie l'objet et retourne une référence, tandis que le post-incrément retourne l'état original de l'objet avant modification. En C++, un paramètre entier factice est utilisé pour distinguer la version postfixée.

class StepCounter {
    friend std::ostream& operator<<(std::ostream& os, const StepCounter& counter);
private:
    int steps;
public:
    StepCounter() : steps(0) {}

    // Pré-incrémentation : retourne une référence
    StepCounter& operator++() {
        ++steps;
        return *this;
    }

    // Post-incrémentation : le paramètre 'int' est un marqueur pour le compilateur
    StepCounter operator++(int) {
        StepCounter tempState = *this;
        ++steps;
        return tempState;
    }
};

std::ostream& operator<<(std::ostream& os, const StepCounter& counter) {
    os << counter.steps;
    return os;
}

void testIncrement() {
    StepCounter tracker;
    std::cout << ++tracker << std::endl; // Affiche 1
    std::cout << tracker++ << std::endl; // Affiche 1, puis incrémente
    std::cout << tracker << std::endl;   // Affiche 2
}

4. Surcharge de l'opérateur d'affectation (=)

Le compilateur génère un opérateur d'affectation par défaut qui effectue une copie superficielle. Si une classe gère des ressources allouées dynamiquement sur le tas, une copie superficeille entraînera des erreurs de double libération. Il est donc crucial de surcharger operator= pour implémenter une copie profonde.

class DynamicBuffer {
private:
    int* m_Data;
    size_t m_Capacity;

public:
    DynamicBuffer(size_t capacity) : m_Capacity(capacity) {
        m_Data = new int[m_Capacity];
    }

    ~DynamicBuffer() {
        delete[] m_Data;
    }

    // Surcharge de l'opérateur d'affectation pour une copie profonde
    DynamicBuffer& operator=(const DynamicBuffer& other) {
        if (this != &other) { // Protection contre l'auto-affectation
            delete[] m_Data;
            m_Capacity = other.m_Capacity;
            m_Data = new int[m_Capacity];
            for (size_t i = 0; i < m_Capacity; ++i) {
                m_Data[i] = other.m_Data[i];
            }
        }
        return *this;
    }
};

void testAssignment() {
    DynamicBuffer buffer1(10);
    DynamicBuffer buffer2(5);
    buffer2 = buffer1; // Copie profonde sécurisée
}

5. Surcharge des opérateurs relationnels (==, !=)

La surcharge des opérateurs de comparaison permet d'évaluer l'égalité ou l'inégalité entre deux objets complexes en comparant leurs attributs internes.

class NetworkNode {
private:
    std::string m_IpAddress;
    int m_Port;

public:
    NetworkNode(std::string ip, int port) : m_IpAddress(ip), m_Port(port) {}

    bool operator==(const NetworkNode& other) const {
        return (this->m_IpAddress == other.m_IpAddress) && (this->m_Port == other.m_Port);
    }

    bool operator!=(const NetworkNode& other) const {
        return !(*this == other);
    }
};

void testRelational() {
    NetworkNode nodeA("192.168.1.1", 8080);
    NetworkNode nodeB("192.168.1.1", 8080);

    if (nodeA == nodeB) {
        std::cout << "Les nœuds sont identiques." << std::endl;
    }
}

6. Surcharge de l'opérateur d'appel de fonction ()

L'opérateur d'appel de fonction peut être surchargé pour permettre à une instance de classe de se comporter comme une fonction. Ces objets sont communément appelés "foncteurs". Ils sont extrêmement flexibles et largement utilisés dans la bibliothèque standard (STL) pour les algorithmes de tri et de recherche.

class ConsoleLogger {
public:
    void operator()(const std::string& message) const {
        std::cout << "[INFO] " << message << std::endl;
    }
};

class Multiplier {
public:
    int operator()(int a, int b) const {
        return a * b;
    }
};

void testFunctors() {
    ConsoleLogger log;
    log("Système initialisé.");

    Multiplier multiply;
    int result = multiply(15, 4);
    std::cout << "Produit : " << result << std::endl;

    // Utilisation d'un objet anonyme
    std::cout << "Produit anonyme : " << Multiplier()(20, 5) << std::endl;
}