Esercizi Membri Amici C++
- Esercizio 1: Funzione amica semplice
- Esercizio 2: Due classi con funzione amica
- Esercizio 3: Funzione amica per l’operatore di inserimento
- Esercizio 4: Funzione amica per l’operatore di uguaglianza
- Esercizio 5: Classe amica
- Esercizio 6: Funzione amica per l’operatore di somma
- Esercizio 7: Funzione amica per accedere a membri privati
- Esercizio 8: Classe amica e funzione amica
Ecco degli esercizi semplici con soluzione per praticare l’utilizzo dei membri amici in C++.
Esercizio 1: Funzione amica semplice
Creare una classe con una funzione amica che accede ai membri privati.
#include <iostream>
class MyClass {private: int valore;public: MyClass(int v) : valore(v) {} friend void stampaValore(const MyClass& obj);};
void stampaValore(const MyClass& obj) { std::cout << "Valore: " << obj.valore << std::endl;}
int main() { MyClass obj(42); stampaValore(obj); return 0;}
Esercizio 2: Due classi con funzione amica
Creare due classi e una funzione amica che accede ai membri privati di entrambe.
#include <iostream>
class ClasseA;class ClasseB;
void scambia(ClasseA& a, ClasseB& b);
class ClasseA {private: int valoreA;public: ClasseA(int v) : valoreA(v) {} friend void scambia(ClasseA& a, ClasseB& b);};
class ClasseB {private: int valoreB;public: ClasseB(int v) : valoreB(v) {} friend void scambia(ClasseA& a, ClasseB& b);};
void scambia(ClasseA& a, ClasseB& b) { int temp = a.valoreA; a.valoreA = b.valoreB; b.valoreB = temp;}
int main() { ClasseA a(10); ClasseB b(20); scambia(a, b); return 0;}
Esercizio 3: Funzione amica per l’operatore di inserimento
Creare una classe con una funzione amica per sovraccaricare l'operatore di inserimento (<<).
#include <iostream>
class Punto {private: int x, y;public: Punto(int x, int y) : x(x), y(y) {} friend std::ostream& operator<<(std::ostream& os, const Punto& p);};
std::ostream& operator<<(std::ostream& os, const Punto& p) { os << "(" << p.x << ", " << p.y << ")"; return os;}
int main() { Punto p(3, 4); std::cout << "Punto: " << p << std::endl; return 0;}
Esercizio 4: Funzione amica per l’operatore di uguaglianza
Creare una classe con una funzione amica per sovraccaricare l'operatore di uguaglianza (==).
#include <iostream>
class Complesso {private: double reale, immaginario;public: Complesso(double r, double i) : reale(r), immaginario(i) {} friend bool operator==(const Complesso& c1, const Complesso& c2);};
bool operator==(const Complesso& c1, const Complesso& c2) { return (c1.reale == c2.reale) && (c1.immaginario == c2.immaginario);}
int main() { Complesso c1(1.0, 2.0); Complesso c2(1.0, 2.0); if (c1 == c2) { std::cout << "I numeri complessi sono uguali" << std::endl; } else { std::cout << "I numeri complessi non sono uguali" << std::endl; } return 0;}
Esercizio 5: Classe amica
Creare due classi dove una è amica dell'altra e accede ai suoi membri privati.
#include <iostream>
class ClasseB;
class ClasseA {private: int valoreA;public: ClasseA(int v) : valoreA(v) {} void stampaB(const ClasseB& b);};
class ClasseB {private: int valoreB;public: ClasseB(int v) : valoreB(v) {} friend class ClasseA;};
void ClasseA::stampaB(const ClasseB& b) { std::cout << "ValoreB: " << b.valoreB << std::endl;}
int main() { ClasseA a(10); ClasseB b(20); a.stampaB(b); return 0;}
Esercizio 6: Funzione amica per l’operatore di somma
Creare una classe con una funzione amica per sovraccaricare l'operatore di somma (+).
#include <iostream>
class Vettore {private: int x, y;public: Vettore(int x, int y) : x(x), y(y) {} friend Vettore operator+(const Vettore& v1, const Vettore& v2); friend std::ostream& operator<<(std::ostream& os, const Vettore& v);};
Vettore operator+(const Vettore& v1, const Vettore& v2) { return Vettore(v1.x + v2.x, v1.y + v2.y);}
std::ostream& operator<<(std::ostream& os, const Vettore& v) { os << "(" << v.x << ", " << v.y << ")"; return os;}
int main() { Vettore v1(1, 2); Vettore v2(3, 4); Vettore v3 = v1 + v2; std::cout << "Somma: " << v3 << std::endl; return 0;}
Esercizio 7: Funzione amica per accedere a membri privati
Creare una classe con una funzione amica che modifica i membri privati della classe.
#include <iostream>
class Contatore {private: int valore;public: Contatore(int v) : valore(v) {} friend void incrementa(Contatore& c); void stampa() const { std::cout << "Valore: " << valore << std::endl; }};
void incrementa(Contatore& c) { c.valore++;}
int main() { Contatore c(5); c.stampa(); incrementa(c); c.stampa(); return 0;}
Esercizio 8: Classe amica e funzione amica
Creare due classi amiche con funzioni amiche che accedono ai membri privati di entrambe.
#include <iostream>
class ClasseB;
class ClasseA {private: int valoreA;public: ClasseA(int v) : valoreA(v) {} void stampaB(const ClasseB& b); friend void incrementaA(ClasseA& a); friend class ClasseB;};
class ClasseB {private: int valoreB;public: ClasseB(int v) : valoreB(v) {} void stampaA(const ClasseA& a); friend void incrementaB(ClasseB& b); friend class ClasseA;};
void ClasseA::stampaB(const ClasseB& b) { std::cout << "ValoreB: " << b.valoreB << std::endl;}
void ClasseB::stampaA(const ClasseA& a) { std::cout << "ValoreA: " << a.valoreA << std::endl;}
void incrementaA(ClasseA& a) { a.valoreA++;}
void incrementaB(ClasseB& b) { b.valoreB++;}
int
main() { ClasseA a(10); ClasseB b(20);
a.stampaB(b); b.stampaA(a);
incrementaA(a); incrementaB(b);
a.stampaB(b); b.stampaA(a);
return 0;}