AULA 13 - Programação II - Graduação
Mecanismo 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.
As declarações da função "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()".
#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 Amigas
Da mesma forma que podemos declarar funções como amigas de uma determinada classe, podemos declarar outra classe como sua amiga. 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.
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.
Sintaxe:
class NomeClasse{
...
friend class NomeClasseAmiga;
...
};
Exemplos:
Para declarar duas classes que são amigas, um da outra, a segunda classe inteira deve ser especificada como amiga da primeira classe. A razão para essa restrição é que o compilador tem informações suficientes para declarar funções individuais de amigo somente no ponto onde a segunda classe é declarada.
#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;
}
Nota:
Não há a propriedade de reciprocidade (ou reversão).
Isto é, 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.
Outra propriedade é que não há transitividade. 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.
Membros de classe como amigos
As funções membro da classe podem ser declaradas como amigos em outras classes. Considere o exemplo a seguir:
// classes_as_friends1.cpp // compile with: /c
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
No exemplo anterior, somente a função A::Func1( B& ) tem acesso de amigo para classificar B. Em virtude disso, o acesso ao membro particular _b está correto em Func1 da classe A mas não em Func2.
Uma classe friend é uma classe cujas funções membro são as funções amigas de uma classe, ou seja, cujas funções membro tenham acesso aos outros membros particulares e protegidos da classe. Suponha que a declaração friend na classe B fosse:
friend class A;
Nesse caso, todas as funções membro na classe A receberão acesso de amigo para classificar B. O código a seguir é um exemplo de uma classe de amigo:
// classes_as_friends2.cpp // compile with: /EHsc
- include <iostream>
using namespace std; class YourClass { friend class YourOtherClass; // Declare a friend class public:
YourClass() : topSecret(0){}
void printMember() { cout << topSecret << endl; }
private:
int topSecret;
};
class YourOtherClass { public:
void change( YourClass& yc, int x ){yc.topSecret = x;}
};
int main() {
YourClass yc1; YourOtherClass yoc1; yc1.printMember(); yoc1.change( yc1, 5 ); yc1.printMember();
}
A amizade não é mútua a menos que explicitamente especificada como tal. No exemplo anterior, as funções membro de YourClass não podem acessar os membros privados de YourOtherClass.
Um tipo gerenciado não pode ter nenhuma função de amigo, classes de amigo ou interfaces de amigo.
A amizade não é herdada, o que significa que as classes derivadas de YourOtherClass não podem acessar os membros privados de YourClass. A amizade não é transitiva, assim as classes que são amigos de YourOtherClass não podem acessar membros privados de YourClass.
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).
Gráfico de implicações de relacionamento de amigo Implicações da relação de amigo
Definições de amigo embutidas As funções friend podem ser definidas nas declarações de classe. Essas funções são funções embutidas, e como funções membro embutidas, se comportam como se fossem definidas imediatamente após todos os membros de classe terem sido vistos, mas antes que o escopo de classe seja fechado (o final da declaração de classe).
As funções friend definidas dentro de declarações de classe não são consideradas no escopo da classe delimitadora; elas estão no escopo do arquivo.