Quando você deve usar 'friend' em C ++?

Eu tenho lido as Perguntas frequentes sobre C ++ e fiquei curioso sobre a frienddeclaração. Eu pessoalmente nunca o usei, mas estou interessado em explorar o idioma.

Qual é um bom exemplo de uso friend?

Lendo um pouco mais as perguntas frequentes, gosto da ideia do << >>operador sobrecarregar e adicionar como amigo dessas classes. No entanto, não tenho certeza de como isso não quebra o encapsulamento. Quando essas exceções podem permanecer dentro do rigor que é OOP?

Em primeiro lugar (IMO) não ouça as pessoas que dizem que friendnão é útil. É útil. Em muitas situações, você terá objetos com dados ou funcionalidades que não pretendem estar disponíveis ao público. Isto é particularmente verdade em grandes bases de código com muitos autores que podem estar familiarizados superficialmente com diferentes áreas.

Existem alternativas para o especificador de amigo, mas muitas vezes são complicadas (classes concretas no nível cpp / typedefs mascarados) ou não são infalíveis (comentários ou convenções de nomes de funções).

Para a resposta;

O friendespecificador permite que a classe designada acesse dados ou funcionalidades protegidas dentro da classe que faz a declaração de amigo. Por exemplo, no código abaixo, qualquer pessoa pode pedir o nome de uma criança, mas apenas a mãe e a criança podem mudar o nome.

Você pode levar esse exemplo mais adiante, considerando uma classe mais complexa, como uma Janela. Provavelmente, uma janela terá muitos elementos de função / dados que não devem ser acessíveis ao público, mas SÃO necessários para uma classe relacionada, como um WindowManager.

class Child
{
//Mother class members can access the private parts of class Child.
friend class Mother;

public:

  string name( void );

protected:

  void setName( string newName );
};

No trabalho, usamos amigos para testar código extensivamente. Isso significa que podemos fornecer o encapsulamento adequado e a ocultação de informações para o código principal do aplicativo. Mas também podemos ter um código de teste separado que usa amigos para inspecionar o estado interno e os dados para teste.

Basta dizer que eu não usaria a palavra-chave friend como um componente essencial do seu design.

A friendpalavra-chave tem vários bons usos. Aqui estão os dois usos imediatamente visíveis para mim:

Definição de Amigo

A definição de amigo permite definir uma função no escopo da classe, mas a função não será definida como uma função membro, mas como uma função livre do espaço para nome que o acompanha e não será visível normalmente, exceto pela pesquisa dependente de argumento. Isso o torna especialmente útil para a sobrecarga do operador:

namespace utils {
    class f {
    private:
        typedef int int_type;
        int_type value;

    public:
        // let's assume it doesn't only need .value, but some
        // internal stuff.
        friend f operator+(f const& a, f const& b) {
            // name resolution finds names in class-scope. 
            // int_type is visible here.
            return f(a.value + b.value);
        }

        int getValue() const { return value; }
    };
}

int main() {
    utils::f a, b;
    std::cout << (a + b).getValue(); // valid
}

Classe base privada de CRTP

Às vezes, você encontra a necessidade de uma política precisar acessar a classe derivada:

// possible policy used for flexible-class.
template<typename Derived>
struct Policy {
    void doSomething() {
        // casting this to Derived* requires us to see that we are a 
        // base-class of Derived.
        some_type const& t = static_cast<Derived*>(this)->getSomething();
    }
};

// note, derived privately
template<template<typename> class SomePolicy>
struct FlexibleClass : private SomePolicy<FlexibleClass> {
    // we derive privately, so the base-class wouldn't notice that, 
    // (even though it's the base itself!), so we need a friend declaration
    // to make the base a friend of us.
    friend class SomePolicy<FlexibleClass>;

    void doStuff() {
         // calls doSomething of the policy
         this->doSomething();
    }

    // will return useful information
    some_type getSomething();
};

Você encontrará um exemplo não artificial para isso nesta resposta. Outro código usando isso está nesta resposta. A base CRTP lança esse ponteiro para poder acessar campos de dados da classe derivada usando ponteiros de membro de dados.

@roo : O encapsulamento não é quebrado aqui porque a própria classe determina quem pode acessar seus membros privados. O encapsulamento só seria quebrado se isso pudesse ser causado de fora da classe, por exemplo, se você operator <<proclamasse "eu sou amigo da classe foo".

friendsubstitui o uso de public, não o uso de private!

Na verdade, o FAQ do C ++ já responde a isso .

O exemplo canônico é sobrecarregar o operador <<. Outro uso comum é permitir que um auxiliar ou uma classe de administrador acesse seus internos.

Aqui estão algumas diretrizes que ouvi sobre amigos em C ++. O último é particularmente memorável.

• Seus amigos não são amigos do seu filho.
• Os amigos do seu filho não são seus amigos.
• Somente amigos podem tocar suas partes íntimas.

edit: Lendo o FAQ um pouco mais Gosto da idéia do operador << >> sobrecarregar e adicionar como amigo dessas classes, no entanto, não tenho certeza de como isso não quebra o encapsulamento

Como isso quebraria o encapsulamento?

Você quebra o encapsulamento ao permitir acesso irrestrito a um membro de dados. Considere as seguintes classes:

class c1 {
public:
  int x;
};

class c2 {
public:
  int foo();
private:
  int x;
};

class c3 {
  friend int foo();
private:
  int x;
};

c1é , obviamente, não encapsulado. Qualquer um pode ler e modificar xnele. Não temos como impor nenhum tipo de controle de acesso.

c2é obviamente encapsulado. Não há acesso público a x. Tudo o que você pode fazer é chamar a foofunção, que executa alguma operação significativa na classe .

c3? Isso é menos encapsulado? Permite acesso irrestrito ax ? Permite o acesso a funções desconhecidas?

Não. Permite precisamente uma função para acessar os membros privados da classe. Assim como c2fez. E assim c2, a única função que tem acesso não é "alguma função aleatória e desconhecida", mas "a função listada na definição de classe". Assim c2, podemos ver, apenas olhando as definições de classe, uma lista completa de quem tem acesso.

Então, como exatamente isso é menos encapsulado? A mesma quantidade de código tem acesso aos membros privados da classe. E todos os que têm acesso são listados na definição de classe.

friendnão quebra o encapsulamento. Isso faz com que alguns programadores de Java se sintam desconfortáveis, porque quando dizem "OOP", na verdade querem dizer "Java". Quando eles dizem "Encapsulamento", não significam "membros privados devem ser protegidos contra acessos arbitrários", mas "uma classe Java onde as únicas funções capazes de acessar membros privados são membros da classe", mesmo que isso seja um absurdo completo para várias razões .

Primeiro, como já mostrado, é muito restritivo. Não há razão para que os métodos de amigos não devam fazer o mesmo.

Segundo, não é suficientemente restritivo . Considere uma quarta classe:

class c4 {
public:
  int getx();
  void setx(int x);
private:
  int x;
};

Isso, de acordo com a mentalidade Java acima mencionada, é perfeitamente encapsulado. E, no entanto, permite que qualquer pessoa leia e modifique x . Como isso faz sentido? (dica: não)

Conclusão: o encapsulamento é capaz de controlar quais funções podem acessar membros privados. É não sobre precisamente onde as definições destas funções estão localizados.

Outra versão comum do exemplo de Andrew, o temido código-dístico

parent.addChild(child);
child.setParent(parent);

Em vez de se preocupar se as duas linhas são sempre feitas juntas e em ordem consistente, você pode tornar os métodos privados e ter uma função de amigo para reforçar a consistência:

class Parent;

class Object {
private:
    void setParent(Parent&);

    friend void addChild(Parent& parent, Object& child);
};

class Parent : public Object {
private:
     void addChild(Object& child);

     friend void addChild(Parent& parent, Object& child);
};

void addChild(Parent& parent, Object& child) {
    if( &parent == &child ){ 
        wetPants(); 
    }
    parent.addChild(child);
    child.setParent(parent);
}

Em outras palavras, você pode manter as interfaces públicas menores e aplicar invariantes que atravessam classes e objetos nas funções de amigo.

Você controla os direitos de acesso de membros e funções usando o direito Privado / Protegido / Público? então, assumindo que a ideia de cada um desses três níveis é clara, deve ficar claro que estamos perdendo alguma coisa ...

A declaração de um membro / função como protegida, por exemplo, é bastante genérica. Você está dizendo que esta função está fora do alcance de todos (exceto um filho herdado, é claro). Mas e as exceções? todo sistema de segurança permite que você tenha algum tipo de 'lista branca', certo?

Tão amigo permite que você tenha a flexibilidade de ter um isolamento sólido de objetos, mas permite que uma "brecha" seja criada para as coisas que você acha que são justificadas.

Eu acho que as pessoas dizem que não é necessário, porque sempre existe um design que funcionará sem ele. Eu acho que é semelhante à discussão de variáveis ​​globais: você nunca deve usá-las, sempre há uma maneira de ficar sem elas ... mas, na realidade, você vê casos em que essa acaba sendo a maneira (quase) mais elegante. .. Eu acho que esse é o mesmo caso com os amigos.

Realmente não adianta nada, além de permitir que você acesse uma variável de membro sem usar uma função de configuração

bem, essa não é exatamente a maneira de encarar. A idéia é controlar a OMS pode acessar o que, tendo ou não uma função de configuração, tem pouco a ver com isso.

Encontrei um lugar útil para usar o acesso de amigos: o mais pequeno de funções privadas.

O amigo é útil quando você está construindo um contêiner e deseja implementar um iterador para essa classe.

Tivemos um problema interessante em uma empresa em que trabalhei anteriormente, onde usamos amigos para afetar decentemente. Trabalhei em nosso departamento de estrutura, criamos um sistema básico de nível de mecanismo em nosso sistema operacional personalizado. Internamente, tínhamos uma estrutura de classes:

         Game
        /    \
 TwoPlayer  SinglePlayer

Todas essas classes fizeram parte da estrutura e mantidas por nossa equipe. Os jogos produzidos pela empresa foram construídos sobre essa estrutura, derivados de uma das crianças dos Jogos. O problema era que o Game tinha interfaces para várias coisas às quais o SinglePlayer e o TwoPlayer precisavam acessar, mas que não queríamos expor fora das classes de estrutura. A solução foi tornar essas interfaces privadas e permitir o acesso do TwoPlayer e SinglePlayer a elas por meio de amizade.

Sinceramente, todo esse problema poderia ter sido resolvido com uma melhor implementação de nosso sistema, mas estávamos presos ao que tínhamos.

A resposta curta seria: use friend quando realmente melhorar encapsulamento. Melhorar a legibilidade e a usabilidade (operadores << e >> são o exemplo canônico) também é um bom motivo.

Quanto aos exemplos de aprimoramento do encapsulamento, as classes projetadas especificamente para trabalhar com os internos de outras classes (as classes de teste vêm à mente) são boas candidatas.

O criador do C ++ diz que não está violando nenhum princípio de encapsulamento, e vou citá-lo:

"Amigo" viola o encapsulamento? Não, não tem. "Amigo" é um mecanismo explícito para conceder acesso, assim como a associação. Você não pode (em um programa em conformidade padrão) conceder a si mesmo acesso a uma classe sem modificar sua fonte.

É mais do que claro ...

Outro uso: friend (+ herança virtual) pode ser usado para evitar derivar de uma classe (também conhecida como "tornar uma classe subivivível") => 1 , 2

De 2 :

 class Fred;

 class FredBase {
 private:
   friend class Fred;
   FredBase() { }
 };

 class Fred : private virtual FredBase {
 public:
   ...
 }; 

Para fazer TDD muitas vezes, usei a palavra-chave 'friend' em C ++.

Um amigo pode saber tudo sobre mim?

Atualizado: Encontrei esta resposta valiosa sobre a palavra-chave "friend" no site Bjarne Stroustrup .

"Amigo" é um mecanismo explícito para conceder acesso, assim como a associação.

Você precisa ter muito cuidado com quando / onde usa a friendpalavra - chave e, como você, eu a uso muito raramente. Abaixo estão algumas notas sobre o uso friende as alternativas.

Digamos que você queira comparar dois objetos para ver se são iguais. Você pode:

• Use métodos de acessador para fazer a comparação (verifique todos os ivar e determine a igualdade).
• Ou você pode acessar todos os membros diretamente, tornando-os públicos.

O problema com a primeira opção é que isso pode ser MUITO acessador, que é (ligeiramente) mais lento que o acesso variável direto, mais difícil de ler e complicado. O problema com a segunda abordagem é que você quebra completamente o encapsulamento.

O que seria bom, é se pudéssemos definir uma função externa que ainda pudesse ter acesso aos membros privados de uma classe. Podemos fazer isso com a friendpalavra-chave:

class Beer {
public:
    friend bool equal(Beer a, Beer b);
private:
    // ...
};

O método equal(Beer, Beer)agora tem acesso direto ao ae b's membros privados (que pode ser char *brand, float percentAlcoholetc. Este é um exemplo bastante artificial, você preferiria se aplicam frienda uma sobrecarga == operator, mas nós vamos chegar a isso.

Algumas coisas a serem observadas:

• A friendNÃO é uma função membro da classe
• É uma função comum com acesso especial aos membros privados da classe
• Não substitua todos os acessadores e mutadores por amigos (você também pode fazer tudo public!)
• A amizade não é recíproca
• Amizade não é transitiva
• A amizade não é herdada
• Ou, como explica a FAQ do C ++ : "Só porque concedo a você acesso a mim, não concede automaticamente acesso a seus filhos, não concede automaticamente a seus amigos o acesso a mim e não concede automaticamente acesso a você . "

Eu realmente uso apenas friendsquando é muito mais difícil fazê-lo de outra maneira. Como outro exemplo, muitos de matemática vetor funções são muitas vezes criados como friendsdevido à interoperabilidade dos Mat2x2, Mat3x3, Mat4x4, Vec2, Vec3, Vec4, etc. E é muito mais fácil de ser amigos, em vez de ter que usar acessores em todos os lugares. Conforme apontado, friendgeralmente é útil quando aplicado ao <<(realmente útil para depuração) >>e talvez ao ==operador, mas também pode ser usado para algo como isto:

class Birds {
public:
    friend Birds operator +(Birds, Birds);
private:
    int numberInFlock;
};


Birds operator +(Birds b1, Birds b2) {
    Birds temp;
    temp.numberInFlock = b1.numberInFlock + b2.numberInFlock;
    return temp;
}

Como já disse, não uso com friendmuita frequência, mas de vez em quando é exatamente o que você precisa. Espero que isto ajude!

No que diz respeito ao operador << e operador >>, não há boas razões para tornar esses operadores amigos. É verdade que eles não devem ser funções-membro, mas também não precisam ser amigos.

A melhor coisa a fazer é criar funções públicas de impressão (ostream &) e leitura (istream &). Em seguida, escreva o operador << e o operador >> em termos dessas funções. Isso oferece o benefício adicional de permitir que você virtualize essas funções, o que fornece serialização virtual.

Só estou usando a palavra-chave friend para unittest funções protegidas. Alguns dirão que você não deve testar a funcionalidade protegida. No entanto, acho essa ferramenta muito útil ao adicionar novas funcionalidades.

No entanto, eu não uso a palavra-chave diretamente nas declarações de classe; em vez disso, uso um elegante corte de modelo para obter isso:

template<typename T>
class FriendIdentity {
public:
  typedef T me;
};

/**
 * A class to get access to protected stuff in unittests. Don't use
 * directly, use friendMe() instead.
 */
template<class ToFriend, typename ParentClass>
class Friender: public ParentClass
{
public:
  Friender() {}
  virtual ~Friender() {}
private:
// MSVC != GCC
#ifdef _MSC_VER
  friend ToFriend;
#else
  friend class FriendIdentity<ToFriend>::me;
#endif
};

/**
 * Gives access to protected variables/functions in unittests.
 * Usage: <code>friendMe(this, someprotectedobject).someProtectedMethod();</code>
 */
template<typename Tester, typename ParentClass>
Friender<Tester, ParentClass> & 
friendMe(Tester * me, ParentClass & instance)
{
    return (Friender<Tester, ParentClass> &)(instance);
}

Isso me permite fazer o seguinte:

friendMe(this, someClassInstance).someProtectedFunction();

Trabalha em GCC e MSVC pelo menos.

No C ++, a palavra-chave "friend" é útil na sobrecarga do operador e no Making Bridge.

1.) Palavra-chave Friend na sobrecarga do operador:
Exemplo de sobrecarga do operador é: Digamos que tenhamos uma classe "Point" que possui duas variáveis ​​flutuantes
"x" (para coordenadas x) e "y" (coordenadas y). Agora temos que sobrecarregar "<<"(operador de extração) de forma que, se chamarmos "cout << pointobj", ela imprimirá as coordenadas xey (onde pointobj é um objeto da classe Point). Para fazer isso, temos duas opções:

   1.Overload "operator << ()" funciona na classe "ostream".
   2.Overload "operator << ()" funciona na classe "Point".

   Como usar o objeto ostream cout.As: cout.operator << (Pointobj) (formulário classe ostream). 
   Como chamar operador << (cout, Pointobj) (da classe Point).

Beacause implementamos sobrecarga na classe Point. Então, para chamar essa função sem um objeto, precisamos adicionar uma "friend"palavra-chave, porque podemos chamar uma função de amigo sem um objeto. Agora a declaração da função será As:
"friend ostream &operator<<(ostream &cout, Point &pointobj);"

2.) Palavra-chave Friend ao fazer bridge:
Suponha que tenhamos que criar uma função na qual temos que acessar membro privado de duas ou mais classes (geralmente denominadas "bridge"). Como fazer isso:
Para acessar um membro privado de uma classe, ele deve ser membro dessa classe. Agora, para acessar um membro privado de outra classe, toda classe deve declarar essa função como uma função de amigo. Por exemplo: Suponha que haja duas classes A e B. Uma função "funcBridge()"deseja acessar um membro privado de ambas as classes. Então ambas as classes devem declarar "funcBridge()"como:
friend return_type funcBridge(A &a_obj, B & b_obj);

Acho que isso ajudaria a entender a palavra-chave friend.

Como a referência para declaração de amigo diz:

A declaração de amigo aparece em um corpo de classe e concede a uma função ou outra classe acesso a membros privados e protegidos da classe em que a declaração de amigo aparece.

Assim, como lembrete, existem erros técnicos em algumas das respostas que dizem que friendsó podem visitar membros protegidos .

O exemplo de árvore é um exemplo muito bom: ter um objeto implementado em algumas classes diferentes sem ter um relacionamento de herança.

Talvez você também precise ter um construtor protegido e forçar as pessoas a usar sua fábrica de "amigos".

... Ok, bem, francamente, você pode viver sem ele.

Para fazer TDD muitas vezes, usei a palavra-chave 'friend' em C ++.
Um amigo pode saber tudo sobre mim?

Não, é apenas uma amizade unidirecional: `(

Uma instância específica em que uso friendé ao criar classes Singleton . A friendpalavra-chave permite criar uma função de acessador, que é mais concisa do que sempre ter um método "GetInstance ()" na classe.

/////////////////////////
// Header file
class MySingleton
{
private:
    // Private c-tor for Singleton pattern
    MySingleton() {}

    friend MySingleton& GetMySingleton();
}

// Accessor function - less verbose than having a "GetInstance()"
//   static function on the class
MySingleton& GetMySingleton();


/////////////////////////
// Implementation file
MySingleton& GetMySingleton()
{
    static MySingleton theInstance;
    return theInstance;
}

Funções e classes de amigos fornecem acesso direto a membros privados e protegidos da classe para evitar a quebra do encapsulamento no caso geral. A maioria dos usos é com ostream: gostaríamos de poder digitar:

Point p;
cout << p;

No entanto, isso pode exigir acesso aos dados privados do Point, portanto, definimos o operador sobrecarregado

friend ostream& operator<<(ostream& output, const Point& p);

Existem implicações óbvias no encapsulamento, no entanto. Primeiro, agora a classe ou função de amigo tem acesso total a TODOS os membros da classe, mesmo aqueles que não pertencem a suas necessidades. Segundo, as implementações da classe e do amigo agora estão enredadas ao ponto em que uma mudança interna na classe pode prejudicar o amigo.

Se você vê o amigo como uma extensão da classe, isso não é um problema, logicamente falando. Mas, nesse caso, por que era necessário desenterrar o amigo em primeiro lugar.

Para conseguir a mesma coisa que os 'amigos' pretendem alcançar, mas sem quebrar o encapsulamento, pode-se fazer isso:

class A
{
public:
    void need_your_data(B & myBuddy)
    {
        myBuddy.take_this_name(name_);
    }
private:
    string name_;
};

class B
{
public:
    void print_buddy_name(A & myBuddy)
    {
        myBuddy.need_your_data(*this);
    }
    void take_this_name(const string & name)
    {
        cout << name;
    }
}; 

O encapsulamento não está quebrado, a classe B não tem acesso à implementação interna em A, mas o resultado é o mesmo como se tivéssemos declarado B amigo de A. O compilador otimizará as chamadas de função, resultando no mesmo instruções como acesso direto.

Eu acho que usar 'amigo' é simplesmente um atalho com benefício discutível, mas custo definido.

Pode não ser uma situação real de caso de uso, mas pode ajudar a ilustrar o uso de um amigo entre as classes.

The ClubHouse

class ClubHouse {
public:
    friend class VIPMember; // VIP Members Have Full Access To Class
private:
    unsigned nonMembers_;
    unsigned paidMembers_;
    unsigned vipMembers;

    std::vector<Member> members_;
public:
    ClubHouse() : nonMembers_(0), paidMembers_(0), vipMembers(0) {}

    addMember( const Member& member ) { // ...code }   
    void updateMembership( unsigned memberID, Member::MembershipType type ) { // ...code }
    Amenity getAmenity( unsigned memberID ) { // ...code }

protected:
    void joinVIPEvent( unsigned memberID ) { // ...code }

}; // ClubHouse

A classe dos membros

class Member {
public:
    enum MemberShipType {
        NON_MEMBER_PAID_EVENT,   // Single Event Paid (At Door)
        PAID_MEMBERSHIP,         // Monthly - Yearly Subscription
        VIP_MEMBERSHIP,          // Highest Possible Membership
    }; // MemberShipType

protected:
    MemberShipType type_;
    unsigned id_;
    Amenity amenity_;
public:
    Member( unsigned id, MemberShipType type ) : id_(id), type_(type) {}
    virtual ~Member(){}
    unsigned getId() const { return id_; }
    MemberShipType getType() const { return type_; }
    virtual void getAmenityFromClubHouse() = 0       
};

class NonMember : public Member {
public:
   explicit NonMember( unsigned id ) : Member( id, MemberShipType::NON_MEMBER_PAID_EVENT ) {}   

   void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }
};

class PaidMember : public Member {
public:
    explicit PaidMember( unsigned id ) : Member( id, MemberShipType::PAID_MEMBERSHIP ) {}

    void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }
};

class VIPMember : public Member {
public:
    friend class ClubHouse;
public:
    explicit VIPMember( unsigned id ) : Member( id, MemberShipType::VIP_MEMBERSHIP ) {}

    void getAmenityFromClubHouse() override {
       Amenity = ClubHouse::getAmenity( this->id_ );
    }

    void attendVIPEvent() {
        ClubHouse::joinVIPEvent( this->id );
    }
};

Facilidades

class Amenity{};

Se você olhar para o relacionamento dessas classes aqui; o ClubHouse possui uma variedade de tipos diferentes de associação e acesso à associação. Os membros são todos derivados de uma classe super ou base, pois todos compartilham um ID e um tipo enumerado que são comuns e classes externas podem acessar seus IDs e tipos por meio de funções de acesso encontradas na classe base.

No entanto, através desse tipo de hierarquia dos membros e de suas classes derivadas e seu relacionamento com a classe ClubHouse, a única classe derivada que possui "privilégios especiais" é a classe VIPMember. A classe base e as outras 2 classes derivadas não podem acessar o método joinVIPEvent () do ClubHouse, mas a classe Membro VIP tem esse privilégio como se tivesse acesso completo a esse evento.

Portanto, com o VIPMember e o ClubHouse, é uma via de acesso bidirecional, onde as outras classes de membros são limitadas.

Ao implementar algoritmos de árvore para classe, o código de estrutura que o professor nos deu teve a classe de árvore como amiga da classe de nó.

Realmente não adianta nada, além de permitir que você acesse uma variável de membro sem usar uma função de configuração.

Você pode usar amizade quando classes diferentes (que não herdam uma da outra) estão usando membros particulares ou protegidos da outra classe.

Casos de uso típicos de funções de amigo são operações conduzidas entre duas classes diferentes, acessando membros privados ou protegidos de ambas.

de http://www.cplusplus.com/doc/tutorial/inheritance/ .

Você pode ver este exemplo em que o método não membro acessa os membros privados de uma classe. Este método deve ser declarado nesta mesma classe como um amigo da classe.

// friend functions
#include <iostream>
using namespace std;

class Rectangle {
    int width, height;
  public:
    Rectangle() {}
    Rectangle (int x, int y) : width(x), height(y) {}
    int area() {return width * height;}
    friend Rectangle duplicate (const Rectangle&);
};

Rectangle duplicate (const Rectangle& param)
{
  Rectangle res;
  res.width = param.width*2;
  res.height = param.height*2;
  return res;
}

int main () {
  Rectangle foo;
  Rectangle bar (2,3);
  foo = duplicate (bar);
  cout << foo.area() << '\n';
  return 0;
}

Provavelmente, perdi algo nas respostas acima, mas outro conceito importante no encapsulamento é ocultar a implementação. Reduzir o acesso a membros de dados privados (os detalhes de implementação de uma classe) permite uma modificação muito mais fácil do código posteriormente. Se um amigo acessar diretamente os dados privados, qualquer alteração nos campos de dados de implementação (dados privados), quebre o código que acessa esses dados. O uso de métodos de acesso elimina isso principalmente. Bastante importante eu pensaria.

Você pode aderir aos princípios mais rigorosos e mais pura OOP e garantir que nenhum membro de dados para qualquer classe até ter acessores para que todos os objetos devem ser os únicos que podem saber sobre os seus dados com a única maneira de agir sobre eles é através indiretos mensagens , ou seja, métodos.

Mas mesmo o C # tem uma palavra-chave de visibilidade interna e o Java tem sua acessibilidade no nível do pacote padrão para algumas coisas. O C ++ chega realmente mais perto do ideal de POO, minimizando o comprometimento da visibilidade em uma classe, especificando exatamente qual outra classe e apenas outras classes poderiam ver nela.

Eu realmente não uso C ++, mas se o C # tivesse amigos, eu o faria em vez do modificador interno assembly-global , que eu realmente uso muito. Realmente não quebra o encapsulamento, porque a unidade de implantação no .NET é um assembly.

Mas há o InternalsVisibleTo Attribute (otherAssembly), que age como um mecanismo amigo de assemblagem cruzada . A Microsoft usa isso para montagens de designer visual .

Amigos também são úteis para retornos de chamada. Você pode implementar retornos de chamada como métodos estáticos

class MyFoo
{
private:
    static void callback(void * data, void * clientData);
    void localCallback();
    ...
};

onde callbackchamadas localCallbackinternamente, e oclientData tem sua instância. Na minha opinião,

ou...

class MyFoo
{
    friend void callback(void * data, void * callData);
    void localCallback();
}

O que isso permite é que o amigo seja definido puramente no cpp como uma função no estilo c, e não desorganize a classe.

Da mesma forma, um padrão que eu tenho visto com frequência é colocar todos os membros realmente privados de uma classe em outra classe, declarada no cabeçalho, definida no cpp e amiga. Isso permite que o codificador oculte grande parte da complexidade e do trabalho interno da classe do usuário do cabeçalho.

No cabeçalho:

class MyFooPrivate;
class MyFoo
{
    friend class MyFooPrivate;
public:
    MyFoo();
    // Public stuff
private:
    MyFooPrivate _private;
    // Other private members as needed
};

No cpp,

class MyFooPrivate
{
public:
   MyFoo *owner;
   // Your complexity here
};

MyFoo::MyFoo()
{
    this->_private->owner = this;
}

Torna-se mais fácil ocultar coisas que o rio abaixo não precisa ver dessa maneira.