Esercizi Membri Amici C++

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;
}