Esercizi Classi Annidate C++

Ecco degli esercizi semplici con soluzione per praticare le basi delle classi annidate in C++.

Esercizio 1

Creare una classe con una classe annidata semplice e stamparne un valore.

#include <iostream>

class Esterna {
public:
    class Annidata {
    private:
        int valore;
    public:
        Annidata(int v) : valore(v) {}
        void stampa() {
            std::cout << "Valore: " << valore << std::endl;
        }
    };
};

int main() {
    Esterna::Annidata obj(42);
    obj.stampa();
    return 0;
}

Esercizio 2

Creare una classe annidata per rappresentare un punto 2D all'interno di una classe esterna.

#include <iostream>

class Grafica {
public:
    class Punto2D {
    private:
        int x, y;
    public:
        Punto2D(int x, int y) : x(x), y(y) {}
        void stampa() {
            std::cout << "Punto (" << x << ", " << y << ")" << std::endl;
        }
    };
};

int main() {
    Grafica::Punto2D punto(3, 4);
    punto.stampa();
    return 0;
}

Esercizio 3

Creare una classe annidata per rappresentare un nodo in una lista collegata all'interno di una classe esterna.

#include <iostream>

class ListaCollegata {
private:
    class Nodo {
    public:
        int dato;
        Nodo* prossimo;
        Nodo(int val) : dato(val), prossimo(nullptr) {}
    };

    Nodo* testa;
public:
    ListaCollegata() : testa(nullptr) {}

    void aggiungi(int val) {
        Nodo* nuovoNodo = new Nodo(val);
        nuovoNodo->prossimo = testa;
        testa = nuovoNodo;
    }

    void stampa() {
        Nodo* current = testa;
        while (current) {
            std::cout << current->dato << " -> ";
            current = current->prossimo;
        }
        std::cout << "null" << std::endl;
    }

    ~ListaCollegata() {
        while (testa) {
            Nodo* daCancellare = testa;
            testa = testa->prossimo;
            delete daCancellare;
        }
    }
};

int main() {
    ListaCollegata lista;
    lista.aggiungi(1);
    lista.aggiungi(2);
    lista.aggiungi(3);
    lista.stampa();
    return 0;
}

Esercizio 4

Creare una classe annidata per gestire un albero binario di ricerca.

#include <iostream>

class AlberoBinario {
private:
    class Nodo {
    public:
        int dato;
        Nodo* sinistro;
        Nodo* destro;
        Nodo(int val) : dato(val), sinistro(nullptr), destro(nullptr) {}
    };

    Nodo* radice;

    void inserisci(Nodo*& nodo, int val) {
        if (!nodo) {
            nodo = new Nodo(val);
        } else if (val < nodo->dato) {
            inserisci(nodo->sinistro, val);
        } else {
            inserisci(nodo->destro, val);
        }
    }

    void stampaInOrdine(Nodo* nodo) {
        if (nodo) {
            stampaInOrdine(nodo->sinistro);
            std::cout << nodo->dato << " ";
            stampaInOrdine(nodo->destro);
        }
    }

    void dealloca(Nodo* nodo) {
        if (nodo) {
            dealloca(nodo->sinistro);
            dealloca(nodo->destro);
            delete nodo;
        }
    }

public:
    AlberoBinario() : radice(nullptr) {}

    void inserisci(int val) {
        inserisci(radice, val);
    }

    void stampaInOrdine() {
        stampaInOrdine(radice);
        std::cout << std::endl;
    }

    ~AlberoBinario() {
        dealloca(radice);
    }
};

int main() {
    AlberoBinario albero;
    albero.inserisci(5);
    albero.inserisci(3);
    albero.inserisci(8);
    albero.inserisci(1);
    albero.inserisci(4);
    albero.stampaInOrdine();
    return 0;
}

Esercizio 5

Creare una classe annidata per rappresentare un indirizzo all'interno di una classe Persona.

#include <iostream>
#include <string>

class Persona {
private:
    std::string nome;
    int eta;

public:
    Persona(std::string n, int e) : nome(n), eta(e) {}

    void stampa() {
        std::cout << "Nome: " << nome << ", Età: " << eta << std::endl;
    }

    class Indirizzo {
    private:
        std::string via;
        std::string citta;
    public:
        Indirizzo(std::string v, std::string c) : via(v), citta(c) {}
        void stampa() {
            std::cout << "Indirizzo: " << via << ", " << citta << std::endl;
        }
    };
};

int main() {
    Persona persona("Mario Rossi", 30);
    Persona::Indirizzo indirizzo("Via Roma", "Milano");
    persona.stampa();
    indirizzo.stampa();
    return 0;
}

Esercizio 6

Creare una classe annidata per rappresentare un'automobile con un motore.

#include <iostream>
#include <string>

class Automobile {
private:
    std::string marca;
    std::string modello;

public:
    Automobile(std::string m, std::string mod) : marca(m), modello(mod) {}

    void stampa() {
        std::cout << "Marca: " << marca << ", Modello: " << modello << std::endl;
    }

    class Motore {
    private:
        int cilindrata;
    public:
        Motore(int c) : cilindrata(c) {}
        void stampa() {
            std::cout << "Cilindrata: " << cilindrata << " cc" << std::endl;
        }
    };
};

int main() {
    Automobile auto1("Fiat", "Punto");
    Automobile::Motore motore1(1200);
    auto1.stampa();
    motore1.stampa();
    return 0;
}

Esercizio 7

Creare una classe annidata per rappresentare una matrice con un elemento.

#include <iostream>

class Matrice {
private:
    int righe, colonne;

public:
    Matrice(int r, int c) : righe(r), colonne(c) {}

    class Elemento {
    private:
        int valore;
        int riga, colonna;
    public:
        Elemento(int v, int r, int c) : valore(v), riga(r), colonna(c) {}
        void stampa() {
            std::cout << "Valore: " << valore << " in posizione (" << riga << ", " << colonna << ")" << std::endl;
        }
    };

    void stampaDimensioni() {
        std::cout << "Dimensioni matrice: " << righe << "x" << colonne << std::endl;
    }
};

int main() {
    Matrice matrice(3, 3);
    Matrice::Elemento elemento(5, 1, 1);
    matrice.stampaDimensioni();
    elemento.stampa();
    return 0;
}

Esercizio 8

Creare una classe annidata per rappresentare un libro con un autore.

#include <iostream>
#include <string>

class Libro {
private:
    std::string titolo;
    int pagine;

public:
    Libro(std::string t, int p) : titolo(t), pagine(p) {}

    void stampa() {
        std::cout << "Titolo: " << titolo << ", Pagine: " << pagine << std::endl;
    }

    class Autore {
    private:
        std::string nome;
    public:
        Autore(std::string n) : nome(n) {}
        void stampa() {
            std::cout << "Autore: " << nome << std::endl;
        }
    };
};

int main() {
    Libro libro("Il Signore degli Anelli", 1000);
    Libro::Autore autore("J.R.R. Tolkien");
    libro.stampa();
    autore.stampa();
    return 0;
}

Esercizio 9

Creare una classe annidata per rappresentare una banca con un conto corrente.

#include <iostream>
#include <string>

class Banca {
private:
    std::string nome;

public:
    Banca(std::string n) : nome(n) {}

    void stampa() {
        std::cout << "Nome banca: " << nome << std::endl;
    }

    class ContoCorrente {
    private:
        std::string numeroConto;
        double saldo;
    public:
        ContoCorrente(std::string n, double s) : numeroConto(n), saldo(s) {}
        void stampa() {
            std::cout << "Numero conto: " << numeroConto << ", Saldo: " << saldo << std::endl;
        }
    };
};

int main() {
    Banca banca("Banca Nazionale");
    Banca::ContoCorrente conto("12345ABC", 1000.50);
    banca.stampa();
    conto.stampa();
    return 0;
}

Esercizio 10

Creare una classe annidata per rappresentare una casa con una stanza.

#include <iostream>
#include <string>

class Casa {
private:
    std::string indirizzo;

public:
    Casa(std::string i) : indirizzo(i) {}

    void stampa() {
        std::cout << "Indirizzo: " << indirizzo << std::endl;
    }

    class Stanza {
    private:
        std::string nome;
        int metriQuadri;
    public:
        Stanza(std::string n, int mq) : nome(n), metriQuadri(mq) {}
        void stampa() {
            std::cout << "Stanza: " << nome << ", Metri quadri: " << metriQuadri << std::endl;
        }
    };
};

int main() {
    Casa casa("Via Roma, 1");
    Casa::Stanza stanza("Camera da letto", 20);
    casa.stampa();
    stanza.stampa();
    return 0;
}