Esercizi Sovraccarico Operatori C++

Codegrind Team•Jul 12 2024

Ecco degli esercizi con soluzione per praticare il sovraccarico degli operatori in C++.

Esercizio 1: Sovraccarico dell’operatore di somma (+)

Creare una classe `Complex` per rappresentare numeri complessi e sovraccaricare l'operatore `+` per sommare due numeri complessi.

#include <iostream>

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Sovraccarico dell'operatore +
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }

    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 + c2;
    c3.display(); // 4.0 + 6.0i
    return 0;
}

Esercizio 2: Sovraccarico dell’operatore di sottrazione (-)

Sovraccaricare l'operatore `-` per sottrarre due numeri complessi nella classe `Complex`.

#include <iostream>

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Sovraccarico dell'operatore -
    Complex operator-(const Complex& other) const {
        return Complex(real - other.real, imag - other.imag);
    }

    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(1.0, 2.0);
    Complex c3 = c1 - c2;
    c3.display(); // 2.0 + 2.0i
    return 0;
}

Esercizio 3: Sovraccarico dell’operatore di uguaglianza (==)

Sovraccaricare l'operatore `==` per confrontare due numeri complessi nella classe `Complex`.

#include <iostream>

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Sovraccarico dell'operatore ==
    bool operator==(const Complex& other) const {
        return real == other.real && imag == other.imag;
    }

    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2(3.0, 4.0);
    Complex c3(1.0, 2.0);
    std::cout << std::boolalpha;
    std::cout << "c1 == c2: " << (c1 == c2) << std::endl; // true
    std::cout << "c1 == c3: " << (c1 == c3) << std::endl; // false
    return 0;
}

Esercizio 4: Sovraccarico dell’operatore di assegnazione (=)

Sovraccaricare l'operatore `=` per assegnare un numero complesso a un altro nella classe `Complex`.

#include <iostream>

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Sovraccarico dell'operatore =
    Complex& operator=(const Complex& other) {
        if (this != &other) {
            real = other.real;
            imag = other.imag;
        }
        return *this;
    }

    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

int main() {
    Complex c1(3.0, 4.0);
    Complex c2;
    c2 = c1;
    c2.display(); // 3.0 + 4.0i
    return 0;
}

Esercizio 5: Sovraccarico dell’operatore di accesso ([]) per array

Sovraccaricare l'operatore `[]` per accedere agli elementi di un array nella classe `Array`.

#include <iostream>

class Array {
private:
    int* data;
    size_t size;
public:
    Array(size_t s) : size(s), data(new int[s]()) {}

    ~Array() {
        delete[] data;
    }

    // Sovraccarico dell'operatore []
    int& operator[](size_t index) {
        if (index >= size) {
            throw std::out_of_range("Indice fuori range");
        }
        return data[index];
    }

    size_t getSize() const {
        return size;
    }
};

int main() {
    Array arr(5);
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;

    for (size_t i = 0; i < arr.getSize(); ++i) {
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
    }
    return 0;
}

Esercizio 6: Sovraccarico dell’operatore di input (>>) per la lettura da stream

Sovraccaricare l'operatore `>>` per leggere i dati di un oggetto `Complex` dallo stream di input.

#include <iostream>

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Sovraccarico dell'operatore >>
    friend std::istream& operator>>(std::istream& is, Complex& c) {
        is >> c.real >> c.imag;
        return is;
    }

    void display() const {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

int main() {
    Complex c;
    std::cout << "Inserisci un numero complesso (reale e immaginario): ";
    std::cin >> c;
    c.display();
    return 0;
}

Esercizio 7: Sovraccarico dell’operatore di output (<<) per la scrittura su stream

Sovraccaricare l'operatore `<<` per scrivere i dati di un oggetto `Complex` sullo stream di output.

#include <iostream>

class Complex {
private:
    double real;
    double imag;
public:
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}

    // Sovraccarico dell'operatore <<
    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
        os << c.real << " + " << c.imag << "i";
        return os;
    }
};

int main() {
    Complex c(3.0, 4.0);
    std::cout << "Il numero complesso è: " << c << std::endl;
    return 0;
}

Esercizio 8: Sovraccarico dell’operatore

di incremento (++)

Sovraccaricare l'operatore `++` per incrementare il valore di un oggetto `Counter`.

#include <iostream>

class Counter {
private:
    int value;
public:
    Counter(int v = 0) : value(v) {}

    // Sovraccarico dell'operatore ++ (pre-incremento)
    Counter& operator++() {
        ++value;
        return *this;
    }

    // Sovraccarico dell'operatore ++ (post-incremento)
    Counter operator++(int) {
        Counter temp = *this;
        ++value;
        return temp;
    }

    void display() const {
        std::cout << "Valore: " << value << std::endl;
    }
};

int main() {
    Counter c(5);
    ++c;
    c.display(); // 6
    c++;
    c.display(); // 7
    return 0;
}