Esercizi Classi Annidate C++
Codegrind Team•Jul 12 2024
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;
}