AULA 13 - Programação II - Graduação
Modificador Friend
Uma das principais razões para se usar técnicas de programação orientada a objetos é o isolamento, ou encapsulamento de dados dentro de classes.
Fazendo assim, apenas funções membro podem obter acesso a valores críticos de atributos da classe.
Na maioria das vezes, esconder dados dentro de classes dá aos programas uma boa medida de controle, impedindo a modificação indiscriminada de valores críticos pelos processos em andamento.
Em C++, existe uma maneira de romper a proteção aos membros de uma classe usando as friends, ou amigas.
Friend é um atributo especial de acesso a classes. Com ele declaramos que uma função externa, ou outra classe, é amiga da mesma.
Em resumo, as classes do C++ podem declarar dois tipos de friends:
- Uma classe inteira pode ser friend de uma outra classe
friend class F;
- Uma única função pode ser declarada como sendo uma friend
friend F;
Funções Amigas
Declarar uma função externa "friend" dentro de uma classe, permite que esta possa ler e manipular membros "private" e "protected" (e claro "public" - públicas, o que já seria normalmente permitido, de qualquer maneira) da classe.
Uma função friend pode ser qualquer uma do programa, incluindo funções membros de outra classe.
A função friend pode ser também uma função global do C++.
Se essa função for membro de uma outra classe, apenas essa função, e nenhum outro membro da classe, receberá permissão de acesso aos membros privados da classe que faz a declaração.
Assim, o acesso a membros pode ser restrito para determinadas partes do código.
Declarando uma função específica como amiga de duas classes, dá-se a essa função acesso aos campos privados e protegidos de instâncias de ambas as classes.
Em um projeto típico, a função friend declara parâmetros das duas classes para as quais ela deve a sua amizade.
Dentro da função friend, as instruções podem então acessar normalmente membros escondidos nos parâmetros passados como argumentos para a função.
Sintaxe:
Para fazer com que funções fora do escopo da classe tenham acesso a membros, temos de colocar o protótipo da função externa dentro da classe, precedido da palavra "friend".
Desta forma o compilador passa a ignorar os atributos de restrição de acesso da classe, quando a função acessa membros da mesma.
class NomeClasse{
...
friend tipo NomeFuncao(NomeClasse);
...
};
Exemplos:
#include <iostream>
using namespace std;
class Ponto
{
friend void MudaPrivado( Ponto & );
public:
Ponto( void ) { mi = 0;}
void ImprimePrivado( void ){cout << mi << endl; }
private:
int mi;
};
void MudaPrivado ( Ponto &i ) { i.mi++; } //acesso ao atributo privado de Ponto
int main()
{
Ponto sPonto;
sPonto.ImprimePrivado();
MudaPrivado(sPonto);
sPonto.ImprimePrivado();
return 0;
}
A função externa MudaPrivado() é declarada como Amiga dentro da classe Ponto, por meio de um protótipo.
No código de MudaPrivado() acontece o acesso direto ao atributo privado mi, da classe Ponto.
Para executar a função MudaPrivado() é necessário especificar qual objeto da classe Ponto terá seu atributo modificado.
// friend functions
#include <iostream>
using namespace std;
class CRectangle
{
int width, height;
public:
void set_values (int, int);
int area () {return (width * height);}
friend CRectangle duplicate (CRectangle);
};
void CRectangle::set_values (int a, int b)
{
width = a;
height = b;
}
CRectangle duplicate (CRectangle rectparam)
{
CRectangle rectres;
rectres.width = rectparam.width*2;
rectres.height = rectparam.height*2;
return (rectres);
}
int main ()
{
CRectangle rect, rectb;
rect.set_values (2,3);
cout<< "Area do objeto retangulo original:\n";
cout << rect.area();
cout<< "\n";
rectb = duplicate (rect);
cout<< "Area do retangulo inicializado a partir da funcao amiga:\n";
cout << rectb.area();
cout<< "\n";
return 0;
}
No código acima, a função externa duplicate() é declarada como Amiga da classe CRectangle.
O código-cliente em main() declara dois objetos, rect e rectb como sendo da classe CRectangle.
O primeiro objeto, rect inicializa normalmente seus atributos privados width e height através do método set_values().
Já o objeto recbt o faz, indiretamente, por meio da função amiga duplicate().
#include <iostream>
using namespace std;
class dois;
class um {
friend void exibe (um &c1, dois &c2);
private:
char *s1;
public:
um() { s1 = "Testando..."; }
};
class dois {
friend void exibe (um &c1, dois &c2);
private:
char *s2;
public:
dois() { s2 = "Um, Dois, Tres!"; }
};
void main () {
um c1;
dois c2;
exibe (c1, c2);
}
void exibe (um &c1, dois &c2) {
cout << c1.s1 << c2.s2 << '\n';
}
Neste exemplo, são declaradas duas classes, "um" e "dois".
Como cada uma dessas classes irá se referir à outra e porque o C++ requer que sejam declarados os identificadores antes de usá-los, a classe "dois" é declarada antes da "um".
* Declarar uma classe antecipadamente diz ao compilador para aceitar referências ao nome da classe antes dela ser declarada formalmente.
A declaração da função externa "exibe()" listam os parâmetros de referência "c1" e "c2" dos dois tipos de classe.
Como "exibe()" é amiga das duas classes, suas instruções podem acessar membros privados e protegidos de objetos passados para "exibe()".
Membros de classe como amigos
As funções membro da classe podem ser declaradas como amigos em outras classes.
Exemplos:
#include <iostream>
using namespace std;
class um;
class dois {
private:
char *s2;
public:
dois() { s2 = "Um, Dois, Tres!"; }
void exibe (um &c1); //prototipo da funcao amiga
};
class um {
friend void dois :: exibe (um &c1);
private:
char *s1;
public:
um() { s1 = "Testando..."; }
};
void dois :: exibe (um &c1) {
cout << c1.s1 << s2 << '\n';
}
void main () {
um c1;
dois c2;
c2.exibe (c1);
}
A primeira regra a ser lembrada sobre funções membro friend está relacionada com a ordem das declarações da classe.
A classe que prototipa a função deve vir antes da classe que declara essa função como sendo um friend.
Usar uma declaração antecipada não é suficiente.
Uma outra diferença em relação ao primeiro exemplo, é o modo como a função "exibe()" faz referências aos dados privados das duas classes. A função agora só possui um parâmetro, "one &c1". Como a função é membro da classe "dois", não se faz necessário listar um argumento do tipo "dois".
De fato, fazê-lo seria um erro!!!
A função está encapsulada dentro de "dois"; portanto, a instrução da função "exibe" pode se referir ao campo privado "s2" de "dois" diretamente.
A referência a "c1.s1" é permitida, pois "exibe()" é friend da classe "um".
Como a função "exibe()" é um membro de "dois", ela agora possui um ponteiro this que endereça a instância para a qual a função foi chamada. Consequentemente, o programa não pode mais chamar a função friend diretamente. Ele agora precisa definir uma variável do tipo "dois" e chamar "exibe()" para essa variável.
O uso de funções amigas deve ser evitado sempre que possível, pois diminui a identidade da orientação a objetos. Isto ocorre porque o uso desse mecanismo representa uma quebra no encapsulamento.
Quando passamos a permitir que funções tenham acesso a membros restritos dos objetos fazemos com que agentes externos interfiram na autonomia dos mesmos. Isto pode dificultar a análise de programas muito extensos.
No caso da criação de procedimentos que tem a finalidade de modificar o conteúdo do objeto explicitamente, como nos casos de operadores e modificadores de comportamento, podemos usar as funções amigas "friends" para esta finalidade tomando os devidos cuidados para torná-las muito bem restritas as funções que devem executar.
É muito importante observar se estas funções alteram dados dentro dos objetos que não podem ser modificados. Se as devidas precauções forem tomadas não haverá problemas no uso de funções "friend".
// classes_as_friends1.cpp
class B;
class A
{
public:
int Func1( B& b );
private:
int Func2( B& b );
};
class B
{
private:
int _b;
// A::Func1 é uma função amiga da classe B
// so A::Func1 tem acesso a todos os membros de B
friend int A::Func1( B& );
};
int A::Func1( B& b ) { return b._b; } // OK
int A::Func2( B& b ) { return b._b; } // C2248
Neste exemplo, somente a função A::Func1( B& ) tem acesso de amigo para modificar/acessar B.
Em virtude disso, o acesso ao membro particular _b está correto em Func1() da classe A mas não em Func2()!!!!
Classes Amigas
Da mesma forma que podemos declarar funções como amigas de uma determinada classe, podemos declarar outra classe como sua amiga.
Sintaxe:
class NomeClasse{
...
friend class NomeClasseAmiga;
...
};
Este artifício faz com que os membros da classe onde foi feita a declaração sejam acessíveis à declarada. Assim, a segunda classe passa a ter possibilidade de manipulação livre dos membros da outra.
Suponha que a declaração friend na classe B do exemplo anterior fosse:
friend class A;
Nesse caso, todas as funções membro na classe A, inclusive Func2() receberão acesso de amigo para acessar B.
O código a seguir é um exemplo de uma classe de amigo:
// classes_as_friends2.cpp
#include <iostream>
using namespace std;
class SuaClasse {
friend class SuaOutraClasse; // Declare a friend class
public:
SuaClasse(){topSecret = 0;}
void ImprimeMembro() { cout << topSecret << endl; }
private:
int topSecret;
};
class SuaOutraClasse {
public:
void Muda( SuaClasse& sc, int x ){sc.topSecret = x;}
};
int main() {
SuaClasse sc1;
SuaOutraClasse soc1;
sc1.ImprimeMembro();
soc1.Muda( sc1, 5 );
sc1.ImprimeMembro();
}
Propriedades da Amizade de Classes
A amizade não é mútua, a menos que explicitamente especificada como tal.
No exemplo anterior, as funções membro de SuaClasse não podem acessar os membros privados de SuaOutraClasse.
Isto também é chamado de ausência de reciprocidade (ou reversão): o fato de uma função ou classe ser friend de uma classe não implica o contrário, ou seja, A ser amiga de B não implica que B seja amiga de A.
A amizade não é herdada, o que significa que as classes derivadas de SuaOutraClasse não podem acessar os membros privados de SuaClasse.
A figura a seguir mostra quatro declarações de classe: Base, Derived, aFriend e anotherFriend. Somente a classe aFriend tem acesso direto aos membros privados de Base (e a todos os membros que Base pode ter herdado).
A amizade não é transitiva, assim as classes que são amigos de SuaOutraClasse não podem acessar membros privados de SuaClasse.
Se em uma classe A for declarado que a class B é amiga, e depois, se na classe B estiver declarado que a classe C é amiga de B, isto não implica que A seja amiga de C.
Uma classe aninhada a outra classe somente poderá acessar membros privados da classe englobante, se for declarada como amiga.
Uma classe friend pode ser qualquer outra classe no sistema, geralmente fora da hierarquia da classe a que pertence a "amiga".
Apesar da funcionalidade ser um pouco semelhante à que temos no uso das funções, quando declaramos uma classe como "friend" dentro de outra, teremos todas as funções da primeira com poderes de acesso aos membros da segunda.
Esta característica requer cuidado redobrado quando operações da classe "friend" interferem no conteúdo da outra.
Exemplos:
#include <iostream>
using namespace std;
class X
{
int i;
public:
X() {i=20; }
friend class Z;
};
class Z
{
int j;
public:
Z(){X x; j = x.i+4;}
getZ() {return j;}
};
int main()
{ Z zexemplo;
cout << "Valor de saida: " ;
cout << zexemplo.getZ();
cout<< "\n";
return 0;
}
// friend class
#include <iostream>
using namespace std;
class CSquare;
class CRectangle
{
int width, height;
public:
int area ()
{return (width * height);}
void convert (CSquare a); //consigo acessar porque é friend
};
class CSquare
{
private:
int side;
public:
void set_side (int a) {side=a;}
friend class CRectangle; //declaro friend class
};
void CRectangle::convert (CSquare a)
{
width = a.side;
height = a.side;
}
int main ()
{
CSquare sqr;
CRectangle rect;
sqr.set_side(4);
rect.convert(sqr);
cout << rect.area();
return 0;
}