OOP e Classi in C++

#include <iostream>
#include <string>
using namespace std;

class Rettangolo {
private:                        // Attributi privati (incapsulamento)
    double larghezza;
    double altezza;

public:                         // Interfaccia pubblica
    // Costruttore con parametri + valori di default
    Rettangolo(double l = 1.0, double a = 1.0) {
        // Validazione all'interno del costruttore
        larghezza = (l > 0) ? l : 1.0;
        altezza   = (a > 0) ? a : 1.0;
    }

    // Getters (restituiscono valori)
    double getLarghezza() const { return larghezza; }
    double getAltezza()   const { return altezza; }

    // Setters (modificano valori con validazione)
    void setLarghezza(double l) { if (l > 0) larghezza = l; }
    void setAltezza(double a)   { if (a > 0) altezza = a; }

    // Metodi di calcolo
    double area()       const { return larghezza * altezza; }
    double perimetro()  const { return 2 * (larghezza + altezza); }
    bool   eQuadrato()  const { return larghezza == altezza; }

    // Stampa le info
    void stampa() const {
        cout << "Rettangolo " << larghezza << "x" << altezza
             << " | Area: " << area()
             << " | Perim: " << perimetro()
             << (eQuadrato() ? " [Quadrato]" : "") << "\n";
    }
};

int main() {
    Rettangolo r1(5.0, 3.0);    // Costruttore con parametri
    Rettangolo r2(4.0);          // a = 1.0 (default)
    Rettangolo r3;               // 1x1 (default)
    Rettangolo quadrato(6.0, 6.0);

    r1.stampa();
    r2.stampa();
    r3.stampa();
    quadrato.stampa();

    // Accesso tramite getter/setter
    r1.setLarghezza(10.0);
    cout << "\nDopo setLarghezza(10): ";
    r1.stampa();

    return 0;
}

#include <iostream>
#include <cstring>
using namespace std;

class Stringa {
private:
    char *dati;
    int   lunghezza;

public:
    // Costruttore di default
    Stringa() : dati(nullptr), lunghezza(0) {
        cout << "Costruttore default\n";
    }

    // Costruttore con parametro
    Stringa(const char *s) {
        lunghezza = strlen(s);
        dati = new char[lunghezza + 1];  // Alloca dinamicamente
        strcpy(dati, s);
        cout << "Costruttore(\"" << dati << "\")\n";
    }

    // Costruttore di copia (deep copy)
    Stringa(const Stringa &altro) {
        lunghezza = altro.lunghezza;
        dati = new char[lunghezza + 1];
        strcpy(dati, altro.dati);
        cout << "Costruttore copia(\"" << dati << "\")\n";
    }

    // Distruttore: chiamato automaticamente quando l'oggetto esce dallo scope
    ~Stringa() {
        cout << "Distruttore(\"" << (dati ? dati : "") << "\")\n";
        delete[] dati;   // Libera memoria allocata con new
    }

    // Operatore di assegnamento
    Stringa& operator=(const Stringa &altro) {
        if (this != &altro) {  // self-assignment check
            delete[] dati;
            lunghezza = altro.lunghezza;
            dati = new char[lunghezza + 1];
            strcpy(dati, altro.dati);
        }
        return *this;   // Ritorna riferimento a sé stesso
    }

    void stampa() const {
        cout << "\"" << (dati ? dati : "") << "\" (len=" << lunghezza << ")\n";
    }
};

int main() {
    cout << "--- Creazione ---\n";
    Stringa s1("Hello");
    Stringa s2("World");

    cout << "\n--- Copia ---\n";
    Stringa s3 = s1;          // Costruttore di copia
    Stringa s4;
    s4 = s2;                   // Operatore di assegnamento

    cout << "\n--- Stampa ---\n";
    s1.stampa(); s2.stampa(); s3.stampa(); s4.stampa();

    cout << "\n--- Fine scope (distruttori) ---\n";
    return 0;
}

#include <iostream>
#include <cmath>
using namespace std;

class Vec2D {
public:
    double x, y;

    Vec2D(double x = 0, double y = 0) : x(x), y(y) {}

    // Operatori aritmetici
    Vec2D operator+(const Vec2D &v) const { return {x+v.x, y+v.y}; }
    Vec2D operator-(const Vec2D &v) const { return {x-v.x, y-v.y}; }
    Vec2D operator*(double s)       const { return {x*s, y*s}; }

    // Prodotto scalare
    double operator*(const Vec2D &v) const { return x*v.x + y*v.y; }

    // Operatori di uguaglianza
    bool operator==(const Vec2D &v) const { return x==v.x && y==v.y; }
    bool operator!=(const Vec2D &v) const { return !(*this == v); }

    // Lunghezza del vettore
    double norma() const { return sqrt(x*x + y*y); }

    // Operatore di output (friend per accedere a privati se necessario)
    friend ostream& operator<<(ostream &os, const Vec2D &v) {
        return os << "(" << v.x << ", " << v.y << ")";
    }
};

int main() {
    Vec2D a(3, 4), b(1, 2);

    cout << "a = " << a << "\n";
    cout << "b = " << b << "\n";
    cout << "a + b = " << (a + b) << "\n";
    cout << "a - b = " << (a - b) << "\n";
    cout << "a * 2 = " << (a * 2) << "\n";
    cout << "a · b = " << (a * b) << " (prodotto scalare)\n";
    cout << "|a| = " << a.norma() << "\n";
    cout << "a == b? " << (a == b ? "Si" : "No") << "\n";

    return 0;
}

#include <iostream>
using namespace std;

class Contatore {
private:
    int id;
    static int totale;      // Condiviso da TUTTI gli oggetti della classe

public:
    Contatore() {
        totale++;
        id = totale;
        cout << "Oggetto #" << id << " creato. Totale: " << totale << "\n";
    }

    ~Contatore() {
        cout << "Oggetto #" << id << " distrutto.\n";
        totale--;
    }

    int getId() const { return id; }            // const: non modifica l'oggetto
    static int getTotale() { return totale; }   // static: non ha this
};

int Contatore::totale = 0;  // Inizializzazione fuori dalla classe

int main() {
    cout << "Inizio. Totale: " << Contatore::getTotale() << "\n";
    {
        Contatore a, b, c;
        cout << "Dentro il blocco. Totale: " << Contatore::getTotale() << "\n";
    }
    cout << "Fine blocco. Totale: " << Contatore::getTotale() << "\n";
    return 0;
}