Introdução à função de amigo em C ++
Um recurso exclusivo do programa C ++ é que ele usa encapsulamento para manter os dados agrupados com todas as suas funções operacionais para constituir uma entidade individual. Isso garante que os dados específicos possam ser acessados apenas pelas tarefas que operam nele e não por qualquer outra tarefa fora desta classe. Portanto, nos casos em que a classe externa pode precisar acessar esses dados em particular, usamos essa função específica chamada função "friend". Sabemos que, usando palavras-chave como "protegido" e "privado", não podemos acessar esses dados fora de seu método. Mas, para fins de aplicação em tempo real, há muitos casos em que podemos precisar dos mesmos dados privados / protegidos e usar o já declarado é sempre mais preferível do que criá-lo várias vezes. Vamos ver como declarar e usar uma função de amigo em C ++ neste artigo.
Uma função de amigo durante a declaração é precedida pela palavra-chave "friend", como mostrado aqui:
Sintaxe :
class (
private
protected
friend (arguments list);
)
returnDatatype functionName(arguments list)(
//function from which protected and private keywords
//can be accessed from as this is a friend method of className
)class (
private
protected
friend (arguments list);
)
returnDatatype functionName(arguments list)(
//function from which protected and private keywords
//can be accessed from as this is a friend method of className
)
Conforme mostrado no código acima, a função friend precisa ser declarada na mesma classe em que a palavra-chave protected ou private foi declarada para que esses dados sejam acessíveis fora da classe. Esta função pode ser declarada em qualquer lugar do programa como um método C ++ normal. A definição da função não requer palavras-chave como amigos ou operadores de resolução de escopo.
Exemplos de função de amigo no programa C ++
Vamos verificar um pouco melhor o funcionamento da função amigo, tomando alguns exemplos abaixo.
Exemplo 1
Código:
/* C++ program which exhibits the working of friend function.*/
#include
using namespace std;
class Weight
(
private:
int kilo;
public:
Weight(): kilo(0) ( )
//Declaration of a friend function
friend int addWeight(Weight);
);
// Defining a friend function
int addWeight(Weight w)
(
//accessing private data from non-member function
w.kilo += 17;
return w.kilo;
)
int main()
(
Weight W;
cout<<"Weight: "<< addWeight(W);
return 0;
)
Resultado:
Aqui, a função friend é o método addWeight () que é declarado dentro da classe Weight. Kilo é a palavra-chave privada declarada dentro do método Weight, que é acessada a partir da função addWeight por causa disso. Este exemplo foi apenas para mostrar o uso básico de uma função de amigo, embora não haja uso em tempo real aqui. Vamos agora nos aprofundar em alguns exemplos significativos.
Exemplo 2
Código:
#include
using namespace std;
// Forward declaration
class SecondClass;
class FirstClass (
private:
int first_num;
public:
FirstClass(): first_num(12) ( )
// Declaring a friend function
friend int divide(FirstClass, SecondClass);
);
class SecondClass (
private:
int sec_num;
public:
SecondClass(): sec_num(4) ( )
// Another friend declaration
friend int divide(FirstClass, SecondClass);
);
// Function divide() is the friend function of classes FirstClass and SecondClass
// that accesses the member variables first_num and sec_num
int divide(FirstClass fnum, SecondClass snum)
(
return (fnum.first_num / snum.sec_num);
)
int main()
(
FirstClass fnum;
SecondClass snum;
cout<<"The value got by dividing first by second number: "<< divide(fnum, snum);
return 0;
)
Resultado:
Neste exemplo, as classes FirstClass e SecondClass têm o divide () declarado como uma função de amigo. Portanto, esta função pode acessar os dados das variáveis privadas da classe. Aqui, a função divide () é usada para adicionar variáveis privadas first_num e sec_num de dois objetos fnum e snum e retorna seu valor ao método principal.
Para que isso funcione corretamente, uma declaração de encaminhamento para SecondClass precisa ser feita conforme mostrado no código, pois SecondClass é referenciado no FirstClass usando o programa:
friend int divide(FirstClass, SecondClass);
Classe de amigos: existe uma classe de amigos assim como a função de amigo. A classe Friend também pode acessar as variáveis privadas e protegidas da classe, pois é um amigo dela.
Sintaxe :
class One(
friend class Two;
);
class Two(
);class One(
friend class Two;
);
class Two(
);class One(
friend class Two;
);
class Two(
);
Como mostrado acima, a classe dois é amiga da classe um. Portanto, a classe Dois pode acessar variáveis privadas e protegidas da classe Um. Mas a classe Um não pode acessar variáveis protegidas ou privadas da classe Dois porque essa não é uma amizade mútua. Para amizade mútua, devemos declarar explicitamente. Da mesma forma, essa amizade da classe não é herdada, o que significa que a classe Dois não será amiga das subclasses da classe Um, mesmo que seja amiga da classe Um.
Exemplo 3
Código:
#include
#include
using namespace std;
class Perimeter(
int len, brd, perimeter, temp;
public:
Perimeter(int len, int brd):len(len), brd(brd)
()
void calcPerimeter()(
temp = len + brd;
perimeter = 2 * temp;
)
friend class printClass;
);
class printClass(
public:
void printPerimeter(Perimeter a)(
cout<<"Perimeter = "< )
);
int main()(
Perimeter a(10, 15);
a.calcPerimeter();
printClass p;
p.printPerimeter(a);
return 0;
)#include
#include
using namespace std;
class Perimeter(
int len, brd, perimeter, temp;
public:
Perimeter(int len, int brd):len(len), brd(brd)
()
void calcPerimeter()(
temp = len + brd;
perimeter = 2 * temp;
)
friend class printClass;
);
class printClass(
public:
void printPerimeter(Perimeter a)(
cout<<"Perimeter = "< )
);
int main()(
Perimeter a(10, 15);
a.calcPerimeter();
printClass p;
p.printPerimeter(a);
return 0;
)
Resultado:
Neste código, temos 2 classes: Classe de perímetro, que localiza o perímetro usando os valores de comprimento e largura. Variáveis len, brd, perímetro e temp são todas variáveis particulares do perímetro da classe. Portanto, precisamos fazer do printClass um amigo da classe Perimeter. Este printClass usa o valor Perimeter calculado na função calcPerimeter () na classe Perimeter. Como todos eles são membros particulares, temos que fazer do printPerimeter um amigo da classe Perimeter. Feito isso, precisamos criar um objeto na classe principal para calcular o perímetro e passar esse objeto para a classe printPerimeter para exibir o perímetro.
Recursos da função de amigo em C ++
- O método e a classe para a qual foi declarado amigo não precisam ser os mesmos.
- Como não está no escopo da respectiva classe, não pode ser chamado usando seu objeto.
- Também pode ser chamado como um método normal, mesmo sem o uso do objeto.
- Ele só pode acessar diretamente os nomes dos membros usando o nome do objeto e o operador de associação de pontos juntamente com o nome do membro.
- Não há restrições, pois pode ser declarado na parte privada ou pública.
Conclusão
Considerando todos os recursos discutidos acima e os exemplos de funções de amigo em C ++, também é preciso ter cuidado ao usar as funções de um amigo com inúmeras funções e classes externas, pois isso pode diminuir a importância do encapsulamento de diferentes classes na programação orientada a objetos. Por isso, pode ser um benefício e uma desgraça para o programador.
Artigo recomendado
Este é um guia para a Função Amigo em C ++. Aqui discutimos a função Introdução ao Amigo em C ++ e seus Exemplos, juntamente com Implementação e Saída de Código. você também pode consultar nossos artigos sugeridos para saber mais -
- Função Recursiva em C ++ (Exemplos)
- Os 11 principais recursos do C ++
- Biblioteca C ++ de Aprendizado de Máquina
- Função hash em C com tipos
- Função hash no PHP com sintaxe