Função de amigo C++ e classes de amigo

Função de amigo C++ e classes de amigo

Neste tutorial, aprenderemos a criar funções de amigos e classes de amigos em C++ com a ajuda de exemplos.

A ocultação de dados é um conceito fundamental da programação orientada a objetos. Ele restringe o acesso de membros privados de fora da classe.

Da mesma forma, membros protegidos só podem ser acessados ​​por classes derivadas e são inacessíveis de fora. Por exemplo,

class MyClass {
    private:
        int member1;
}

int main() {
    MyClass obj;

    // Error! Cannot access private members from here.
    obj.member1 = 5;
}

No entanto, há um recurso em C++ chamado funções de amigo que quebram essa regra e nos permitem acessar funções-membro de fora da classe.

Da mesma forma, há uma classe de amigos também, que aprenderemos mais tarde neste tutorial.

---

Função de amigo em C++

Uma função de amigo pode acessar o privado e protegido dados de uma classe. Declaramos uma função de amigo usando o friend palavra-chave dentro do corpo da classe.

class className {
    ... .. ...
    friend returnType functionName(arguments);
    ... .. ...
}

---

Exemplo 1:Funcionamento da função amigo

// C++ program to demonstrate the working of friend function

#include <iostream>
using namespace std;

class Distance {
    private:
        int meter;
        
        // friend function
        friend int addFive(Distance);

    public:
        Distance() : meter(0) {}
        
};

// friend function definition
int addFive(Distance d) {

    //accessing private members from the friend function
    d.meter += 5;
    return d.meter;
}

int main() {
    Distance D;
    cout << "Distance: " << addFive(D);
    return 0;
}

Saída

Distance: 5

Aqui, addFive() é uma função de amigo que pode acessar tanto privado e público membros de dados.

Embora este exemplo nos dê uma ideia sobre o conceito de uma função de amigo, ele não mostra nenhum uso significativo.

Um uso mais significativo seria operar em objetos de duas classes diferentes. É aí que a função de amigo pode ser muito útil.

---

Exemplo 2:adicionar membros de duas classes diferentes

// Add members of two different classes using friend functions

#include <iostream>
using namespace std;

// forward declaration
class ClassB;

class ClassA {
    
    public:
        // constructor to initialize numA to 12
        ClassA() : numA(12) {}
        
    private:
        int numA;
        
         // friend function declaration
         friend int add(ClassA, ClassB);
};

class ClassB {

    public:
        // constructor to initialize numB to 1
        ClassB() : numB(1) {}
    
    private:
        int numB;
 
        // friend function declaration
        friend int add(ClassA, ClassB);
};

// access members of both classes
int add(ClassA objectA, ClassB objectB) {
    return (objectA.numA + objectB.numB);
}

int main() {
    ClassA objectA;
    ClassB objectB;
    cout << "Sum: " << add(objectA, objectB);
    return 0;
}

Saída

Sum: 13

Neste programa, ClassA e ClassB declararam add() como uma função de amigo. Assim, esta função pode acessar privado dados de ambas as classes.

Uma coisa a notar aqui é a função de amigo dentro de ClassA está usando o ClassB . No entanto, não definimos ClassB neste ponto.

// inside classA 
friend int add(ClassA, ClassB);

Para que isso funcione, precisamos de uma declaração de encaminhamento de ClassB em nosso programa.

// forward declaration
class ClassB;

---

classe de amigo em C++

Também podemos usar uma classe de amigo em C++ usando o friend palavra-chave. Por exemplo,

class ClassB;

class ClassA {
   // ClassB is a friend class of ClassA
   friend class ClassB;
   ... .. ...
}

class ClassB {
   ... .. ...
}

Quando uma classe é declarada como classe amiga, todas as funções-membro da classe amiga tornam-se funções amigas.

Desde ClassB é uma classe de amigos, podemos acessar todos os membros de ClassA de dentro de ClassB .

No entanto, não podemos acessar membros de ClassB de dentro de ClassA . É porque a relação de amigo em C++ é apenas concedida, não tomada.

---

Exemplo 3:classe de amigo C++

// C++ program to demonstrate the working of friend class

#include <iostream>
using namespace std;

// forward declaration
class ClassB;

class ClassA {
    private:
        int numA;

        // friend class declaration
        friend class ClassB;

    public:
        // constructor to initialize numA to 12
        ClassA() : numA(12) {}
};

class ClassB {
    private:
        int numB;

    public:
        // constructor to initialize numB to 1
        ClassB() : numB(1) {}
    
    // member function to add numA
    // from ClassA and numB from ClassB
    int add() {
        ClassA objectA;
        return objectA.numA + numB;
    }
};

int main() {
    ClassB objectB;
    cout << "Sum: " << objectB.add();
    return 0;
}

Saída

Sum: 13

Aqui, ClassB é uma classe de amigo de ClassA . Então, ClassB tem acesso aos membros de classA .

Em ClassB , criamos uma função add() que retorna a soma de numA e numB .

Desde ClassB é uma classe amiga, podemos criar objetos de ClassA dentro de ClassB .