Quand devriez-vous utiliser «ami» en C ++?

J'ai lu la FAQ C ++ et j'étais curieux de la frienddéclaration. Personnellement, je ne l'ai jamais utilisé, mais je suis intéressé à explorer la langue.

Quel est un bon exemple d'utilisation friend?

En lisant la FAQ un peu plus longtemps, j'aime l'idée de la << >>surcharge de l' opérateur et de l'ajouter comme ami de ces classes. Cependant, je ne sais pas comment cela ne rompt pas l'encapsulation. Quand ces exceptions peuvent-elles rester dans la rigueur de la POO?

Tout d'abord (l'OMI) n'écoute pas les gens qui disent friend n'est pas utile. C'est utile. Dans de nombreuses situations, vous aurez des objets avec des données ou des fonctionnalités qui ne sont pas destinées à être accessibles au public. Cela est particulièrement vrai pour les grandes bases de code avec de nombreux auteurs qui ne connaissent que superficiellement différents domaines.

Il existe des alternatives au spécificateur ami, mais souvent elles sont lourdes (classes concrètes au niveau cpp / typedefs masqués) ou non infaillibles (commentaires ou conventions de nom de fonction).

Sur la réponse;

Le friendspécificateur permet à la classe désignée d'accéder aux données ou fonctionnalités protégées au sein de la classe faisant la déclaration friend. Par exemple, dans le code ci-dessous, n'importe qui peut demander son nom à un enfant, mais seules la mère et l'enfant peuvent changer le nom.

Vous pouvez prendre cet exemple simple plus loin en considérant une classe plus complexe telle qu'une fenêtre. Il est très probable qu'une fenêtre aura de nombreux éléments de fonction / données qui ne devraient pas être accessibles au public, mais SONT nécessaires à une classe connexe telle qu'un 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 );
};

Au travail, nous utilisons largement des amis pour tester le code . Cela signifie que nous pouvons fournir une encapsulation appropriée et masquer les informations pour le code d'application principal. Mais nous pouvons également avoir un code de test distinct qui utilise des amis pour inspecter l'état interne et les données à tester.

Il suffit de dire que je n'utiliserais pas le mot-clé ami comme élément essentiel de votre conception.

Le friendmot-clé a plusieurs bonnes utilisations. Voici les deux utilisations immédiatement visibles pour moi:

Définition d'ami

La définition de Friend permet de définir une fonction dans la portée de classe, mais la fonction ne sera pas définie comme une fonction membre, mais comme une fonction libre de l'espace de noms englobant, et ne sera pas visible normalement, sauf pour la recherche dépendante de l'argument. Cela le rend particulièrement utile pour la surcharge de l'opérateur:

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 de base CRTP privée

Parfois, vous trouvez la nécessité pour une stratégie d'accéder à la classe dérivée:

// 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();
};

Vous trouverez un exemple non artificiel pour cela dans cette réponse. Un autre code utilisant cela est dans cette réponse. La base CRTP jette son ce pointeur, pour pouvoir accéder aux champs de données de la classe dérivée en utilisant des pointeurs de membres de données.

@roo : L'encapsulation n'est pas interrompue ici car la classe elle-même dicte qui peut accéder à ses membres privés. L'encapsulation ne serait interrompue que si cela pouvait être causé de l'extérieur de la classe, par exemple si vous operator <<proclamiez «Je suis un ami de classe foo».

friendremplace l'utilisation de public, pas l'utilisation de private!

En fait, la FAQ C ++ y répond déjà .

L'exemple canonique est de surcharger l'opérateur <<. Une autre utilisation courante consiste à autoriser un assistant ou une classe d'administration à accéder à vos éléments internes.

Voici quelques directives que j'ai entendues sur les amis C ++. Le dernier est particulièrement mémorable.

• Vos amis ne sont pas les amis de votre enfant.
• Les amis de votre enfant ne sont pas vos amis.
• Seuls les amis peuvent toucher vos parties intimes.

edit: Lire la faq un peu plus longtemps j'aime l'idée de l'opérateur << >> surcharger et ajouter comme ami de ces classes, mais je ne sais pas comment cela ne rompt pas l'encapsulation

Comment romprait-elle l'encapsulation?

Vous rompez l'encapsulation lorsque vous autorisez un accès illimité à un membre de données. Considérez les classes suivantes:

class c1 {
public:
  int x;
};

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

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

c1n'est évidemment pas encapsulé. Tout le monde peut y lire et le modifier x. Nous n'avons aucun moyen d'imposer un type de contrôle d'accès.

c2est évidemment encapsulé. Il n'y a pas d'accès public à x. Tout ce que vous pouvez faire est d'appeler la foofonction, qui effectue une opération significative sur la classe .

c3? Est-ce moins encapsulé? Permet-il un accès illimité à x? Permet-il l'accès à des fonctions inconnues?

Non. Il permet précisément à une fonction d'accéder aux membres privés de la classe. Tout comme l'a c2fait. Et tout comme c2, la seule fonction qui a accès n'est pas «une fonction inconnue aléatoire», mais «la fonction répertoriée dans la définition de classe». Tout comme c2, nous pouvons voir, juste en regardant les définitions de classe, une liste complète de qui a accès.

Alors, comment est-ce exactement moins encapsulé? La même quantité de code a accès aux membres privés de la classe. Et tous ceux qui y ont accès sont répertoriés dans la définition de classe.

friendne rompt pas l'encapsulation. Cela met certains programmeurs Java mal à l'aise, car lorsqu'ils disent "OOP", ils signifient en fait "Java". Quand ils disent "encapsulation", ils ne signifient pas "les membres privés doivent être protégés contre les accès arbitraires", mais "une classe Java où les seules fonctions capables d'accéder aux membres privés, sont des membres de classe", même si cela n'a aucun sens pour plusieurs raisons .

Premièrement, comme déjà montré, c'est trop restrictif. Il n'y a aucune raison pour que les méthodes amis ne soient pas autorisées à faire de même.

Deuxièmement, ce n'est pas assez restrictif . Considérons une quatrième classe:

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

Ceci, selon la mentalité Java précitée, est parfaitement encapsulé. Et pourtant, cela permet à quiconque de lire et de modifier x . Comment cela a-t-il même un sens? (indice: ce n'est pas le cas)

Conclusion: l'encapsulation consiste à pouvoir contrôler les fonctions pouvant accéder aux membres privés. Il ne s'agit pas précisément de l'emplacement des définitions de ces fonctions.

Une autre version courante de l'exemple d'Andrew, le redouté couplet de code

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

Au lieu de vous inquiéter si les deux lignes sont toujours effectuées ensemble et dans un ordre cohérent, vous pouvez rendre les méthodes privées et avoir une fonction amie pour appliquer la cohérence:

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);
}

En d'autres termes, vous pouvez réduire la taille des interfaces publiques et appliquer des invariants qui traversent les classes et les objets dans les fonctions ami.

Vous contrôlez les droits d'accès des membres et des fonctions en utilisant le droit Privé / Protégé / Public? donc en supposant que l'idée de chacun de ces 3 niveaux est claire, alors il devrait être clair que nous manquons quelque chose ...

La déclaration d'un membre / fonction comme protégé par exemple est assez générique. Vous dites que cette fonction est hors de portée pour tout le monde (sauf pour un enfant hérité bien sûr). Mais qu'en est-il des exceptions? chaque système de sécurité vous permet d'avoir une sorte de «liste blanche», n'est-ce pas?

Alors, ami, vous avez la possibilité d'avoir une isolation solide contre les objets, mais permet de créer une "faille" pour les choses que vous jugez justifiées.

Je suppose que les gens disent que ce n'est pas nécessaire car il y a toujours un design qui s'en passera. Je pense que c'est similaire à la discussion des variables globales: vous ne devriez jamais les utiliser, il y a toujours un moyen de s'en passer ... mais en réalité, vous voyez des cas où cela finit par être le moyen (presque) le plus élégant. .. Je pense que c'est le même cas avec des amis.

Cela ne fait pas vraiment de bien, à part vous permettre d'accéder à une variable membre sans utiliser une fonction de réglage

eh bien ce n'est pas exactement la façon de voir les choses. L’idée est de contrôler l’OMS qui peut accéder à quoi, ayant ou non fonction de réglage n'a pas grand-chose à voir avec cela.

J'ai trouvé un endroit pratique pour utiliser l'accès ami: la plus petite des fonctions privées.

Friend est utile lorsque vous créez un conteneur et que vous souhaitez implémenter un itérateur pour cette classe.

Nous avons eu un problème intéressant dans une entreprise où je travaillais auparavant, où nous avons utilisé un ami pour un effet décent. J'ai travaillé dans notre service de cadre, nous avons créé un système de niveau moteur de base sur notre système d'exploitation personnalisé. En interne, nous avions une structure de classe:

         Game
        /    \
 TwoPlayer  SinglePlayer

Toutes ces classes faisaient partie du cadre et maintenues par notre équipe. Les jeux produits par la société ont été construits au-dessus de ce cadre dérivé d'un des enfants des Jeux. Le problème était que Game avait des interfaces avec diverses choses auxquelles SinglePlayer et TwoPlayer avaient besoin d'accéder mais que nous ne voulions pas exposer en dehors des classes de framework. La solution consistait à rendre ces interfaces privées et à permettre à TwoPlayer et SinglePlayer d'y accéder via l'amitié.

En vérité, tout ce problème aurait pu être résolu par une meilleure mise en œuvre de notre système, mais nous étions enfermés dans ce que nous avions.

La réponse courte serait: utilisez ami lorsque cela améliore réellement l' encapsulation. L'amélioration de la lisibilité et de l'utilisabilité (les opérateurs << et >> sont l'exemple canonique) est également une bonne raison.

En ce qui concerne les exemples d'amélioration de l'encapsulation, les classes spécialement conçues pour fonctionner avec les internes d'autres classes (les classes de test me viennent à l'esprit) sont de bons candidats.

Le créateur de C ++ dit que cela ne rompt aucun principe d'encapsulation, et je vais le citer:

"Ami" viole-t-il l'encapsulation? Non. "Friend" est un mécanisme explicite pour accorder l'accès, tout comme l'adhésion. Vous ne pouvez pas (dans un programme conforme standard) vous accorder l'accès à une classe sans modifier sa source.

C'est plus que clair ...

Une autre utilisation: ami (+ héritage virtuel) peut être utilisé pour éviter de dériver d'une classe (aka: "rendre une classe insécable") => 1 , 2

À partir de 2 :

 class Fred;

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

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

Pour faire TDD plusieurs fois, j'ai utilisé le mot-clé «ami» en C ++.

Un ami peut-il tout savoir sur moi?

Mise à jour: j'ai trouvé cette précieuse réponse sur le mot-clé "ami" du site Bjarne Stroustrup .

"Friend" est un mécanisme explicite pour accorder l'accès, tout comme l'adhésion.

Vous devez être très prudent quand / où vous utilisez le friendmot - clé et, comme vous, je l'ai utilisé très rarement. Voici quelques notes sur l'utilisation friendet les alternatives.

Disons que vous voulez comparer deux objets pour voir s'ils sont égaux. Vous pouvez soit:

• Utilisez des méthodes d'accesseur pour faire la comparaison (vérifiez chaque ivar et déterminez l'égalité).
• Ou, vous pouvez accéder directement à tous les membres en les rendant publics.

Le problème avec la première option, c'est que cela pourrait être BEAUCOUP d'accessoires, qui est (légèrement) plus lent que l'accès variable direct, plus difficile à lire et encombrant. Le problème avec la deuxième approche est que vous rompez complètement l'encapsulation.

Ce qui serait bien, c'est si nous pouvions définir une fonction externe qui pourrait toujours avoir accès aux membres privés d'une classe. Nous pouvons le faire avec le friendmot clé:

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

La méthode equal(Beer, Beer)a un accès direct maintenant aet bmembres privés »(qui peut être char *brand, float percentAlcoholetc. Ceci est un exemple plutôt arrangé, vous appliqueriez plus tôt friendà une surcharge == operator, mais nous y reviendrons.

Quelques points à noter:

• A friendn'est PAS une fonction membre de la classe
• C'est une fonction ordinaire avec un accès spécial aux membres privés de la classe
• Ne remplacez pas tous les accesseurs et mutateurs par des amis (vous pouvez aussi tout faire public!)
• L'amitié n'est pas réciproque
• L'amitié n'est pas transitive
• L'amitié n'est pas héritée
• Ou, comme l' explique la FAQ C ++ : "Ce n'est pas parce que je vous accorde un accès d'amitié que vos enfants m'accèdent automatiquement, n'accorde pas automatiquement l'accès à vos amis et ne m'autorise pas automatiquement . "

Je ne l'utilise vraiment que friendslorsqu'il est beaucoup plus difficile de le faire dans l'autre sens. Comme autre exemple, beaucoup de mathématiques vecteur fonctions sont souvent créés en friendsraison de l'interopérabilité Mat2x2, Mat3x3, Mat4x4, Vec2, Vec3, Vec4, etc. Et il est tellement plus facile d'être amis, plutôt que d' avoir à utiliser accesseurs partout. Comme indiqué, friendest souvent utile lorsqu'il est appliqué à <<(vraiment pratique pour le débogage), >>et peut-être à l' ==opérateur, mais peut également être utilisé pour quelque chose comme ceci:

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;
}

Comme je l'ai dit, je n'utilise pas du friendtout très souvent, mais de temps en temps c'est exactement ce dont vous avez besoin. J'espère que cela t'aides!

En ce qui concerne l'opérateur << et l'opérateur >>, il n'y a aucune bonne raison de se faire des amis. Il est vrai qu'ils ne devraient pas être des fonctions membres, mais ils n'ont pas non plus besoin d'être amis.

La meilleure chose à faire est de créer des fonctions publiques d'impression (ostream &) et de lecture (istream &). Ensuite, écrivez l'opérateur << et l'opérateur >> en fonction de ces fonctions. Cela donne l'avantage supplémentaire de vous permettre de rendre ces fonctions virtuelles, ce qui permet une sérialisation virtuelle.

J'utilise uniquement le mot-clé friend pour les fonctions protégées les plus complètes. Certains diront que vous ne devriez pas tester la fonctionnalité protégée. Je trouve cependant cet outil très utile lors de l'ajout de nouvelles fonctionnalités.

Cependant, je n'utilise pas le mot clé directement dans les déclarations de classe, j'utilise plutôt un astucieux modèle-hack pour y parvenir:

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);
}

Cela me permet de faire ce qui suit:

friendMe(this, someClassInstance).someProtectedFunction();

Fonctionne sur GCC et MSVC au moins.

En C ++, le mot-clé "friend" est utile dans la surcharge de l'opérateur et la création d'un pont.

1.) Mot-clé ami dans la surcharge d'opérateur:
Exemple de surcharge d'opérateur: Supposons que nous ayons une classe "Point" qui a deux variables flottantes
"x" (pour la coordonnée x) et "y" (pour la coordonnée y). Maintenant, nous devons surcharger "<<"(opérateur d'extraction) de telle sorte que si nous appelons"cout << pointobj" il affichera les coordonnées x et y (où pointobj est un objet de la classe Point). Pour ce faire, nous avons deux options:

   1.Surcharger la fonction "operator << ()" dans la classe "ostream".
   2.Overload "operator << ()" function in "Point" class.

   1.Utilisation de l'objet ostream cout.As: cout.operator << (Pointobj) (forme ostream class). 
   2.Appelez sans objet. Comme: opérateur << (cout, Pointobj) (de la classe Point).

Parce que nous avons implémenté la surcharge dans la classe Point. Donc, pour appeler cette fonction sans objet, nous devons ajouter un "friend"mot-clé car nous pouvons appeler une fonction amie sans objet. Maintenant, la déclaration de fonction sera As:
"friend ostream &operator<<(ostream &cout, Point &pointobj);"

2.) Mot-clé Friend dans la création d'un pont:
supposons que nous devons créer une fonction dans laquelle nous devons accéder à un membre privé de deux classes ou plus (généralement appelé "pont"). Comment faire:
pour accéder au membre privé d'une classe, il doit être membre de cette classe. Maintenant, pour accéder à un membre privé d'une autre classe, chaque classe doit déclarer cette fonction comme une fonction amie. Par exemple: Supposons qu'il existe deux classes A et B. Une fonction "funcBridge()"souhaite accéder au membre privé des deux classes. Ensuite, les deux classes doivent déclarer "funcBridge()":
friend return_type funcBridge(A &a_obj, B & b_obj);

Je pense que cela aiderait à comprendre le mot-clé ami.

Comme le dit la référence pour la déclaration d'ami :

La déclaration friend apparaît dans un corps de classe et accorde à une fonction ou à une autre classe l'accès aux membres privés et protégés de la classe où la déclaration friend apparaît.

Donc, juste pour rappel, il y a des erreurs techniques dans certaines des réponses qui disent que friendseuls les membres protégés peuvent visiter .

L'exemple d'arbre est un très bon exemple: avoir un objet implémenté dans quelques classes différentes sans avoir de relation d'héritage.

Peut-être pourriez-vous également en avoir besoin pour protéger un constructeur et forcer les gens à utiliser votre usine "ami".

... Ok, bien franchement vous pouvez vous en passer.

Pour faire TDD plusieurs fois, j'ai utilisé le mot-clé «ami» en C ++.
Un ami peut-il tout savoir sur moi?

Non, c'est seulement une amitié à sens unique: `(

Une instance spécifique où j'utilise friendest lors de la création de classes Singleton . Le friendmot-clé me ​​permet de créer une fonction d'accesseur, qui est plus concise que d'avoir toujours une méthode "GetInstance ()" sur la 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;
}

Les fonctions et classes Friend fournissent un accès direct aux membres privés et protégés de la classe pour éviter de briser l'encapsulation dans le cas général. La plupart des utilisations se font avec ostream: nous aimerions pouvoir taper:

Point p;
cout << p;

Cependant, cela peut nécessiter l'accès aux données privées de Point, nous définissons donc l'opérateur surchargé

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

Il y a cependant des implications évidentes d'encapsulation. Tout d'abord, la classe ou la fonction ami a désormais un accès complet à TOUS les membres de la classe, même ceux qui ne correspondent pas à ses besoins. Deuxièmement, les implémentations de la classe et de l'ami sont désormais imbriquées au point où un changement interne dans la classe peut briser l'ami.

Si vous voyez l'ami comme une extension de la classe, ce n'est pas un problème, logiquement. Mais, dans ce cas, pourquoi était-il nécessaire de spearer l'ami en premier lieu.

Pour atteindre la même chose que les «amis» prétendent accomplir, mais sans rompre l'encapsulation, on peut le faire:

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;
    }
}; 

L'encapsulation n'est pas rompue, la classe B n'a pas accès à l'implémentation interne dans A, mais le résultat est le même que si nous avions déclaré B ami de A. Le compilateur optimisera les appels de fonction, ce qui entraînera la même chose instructions comme accès direct.

Je pense que l'utilisation de «ami» est simplement un raccourci avec des avantages discutables, mais un coût certain.

Il ne s'agit peut-être pas d'une situation d'utilisation réelle, mais cela peut aider à illustrer l'utilisation d'amis entre les 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

La classe des membres

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 );
    }
};

Agréments

class Amenity{};

Si vous regardez la relation de ces classes ici; le ClubHouse détient une variété de différents types d'adhésions et d'accès aux membres. Les membres sont tous dérivés d'une classe super ou de base car ils partagent tous un ID et un type énuméré qui sont des classes communes et externes peuvent accéder à leurs ID et types via des fonctions d'accès qui se trouvent dans la classe de base.

Cependant, à travers ce type de hiérarchie des membres et de ses classes dérivées et de leur relation avec la classe ClubHouse, la seule classe dérivée qui a des "privilèges spéciaux" est la classe VIPMember. La classe de base et les 2 autres classes dérivées ne peuvent pas accéder à la méthode joinVIPEvent () de ClubHouse, mais la classe Membre VIP a ce privilège comme si elle avait un accès complet à cet événement.

Ainsi, avec le VIPMember et le ClubHouse, il s'agit d'une rue d'accès à double sens où les autres classes membres sont limitées.

Lors de l'implémentation d'algorithmes d'arbre pour la classe, le code cadre que le prof nous a donné avait la classe d'arbre en tant qu'ami de la classe de noeud.

Cela ne fait pas vraiment de bien, à part vous permettre d'accéder à une variable membre sans utiliser de fonction de réglage.

Vous pouvez utiliser l'amitié lorsque différentes classes (n'héritant pas l'une de l'autre) utilisent des membres privés ou protégés de l'autre classe.

Les cas d'utilisation typiques des fonctions ami sont des opérations qui sont effectuées entre deux classes différentes accédant à des membres privés ou protégés des deux.

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

Vous pouvez voir cet exemple où la méthode non membre accède aux membres privés d'une classe. Cette méthode doit être déclarée dans cette même classe en tant qu'ami de la 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;
}

J'ai probablement manqué quelque chose dans les réponses ci-dessus, mais un autre concept important dans l'encapsulation cache la mise en œuvre. La réduction de l'accès aux données privées membres (les détails d'implémentation d'une classe) permet une modification beaucoup plus facile du code ultérieurement. Si un ami accède directement aux données privées, toute modification des champs de données d'implémentation (données privées), casse le code d'accès à ces données. L'utilisation de méthodes d'accès élimine principalement cela. Assez important, je pense.

Vous pouvez adhérer aux principes de POO les plus stricts et les plus purs et vous assurer qu'aucun membre de données pour aucune classe n'a même des accesseurs de sorte que tous les objets doivent être les seuls à pouvoir connaître leurs données avec la seule façon d'agir sur eux via des messages indirects , c'est-à-dire les méthodes.

Mais même C # a un mot-clé de visibilité interne et Java a son accessibilité au niveau du package par défaut pour certaines choses. C ++ se rapproche en fait de l'idéal OOP en minimisant le compromis de visibilité dans une classe en spécifiant exactement quelle autre classe et seulement d' autres classes pourraient y voir.

Je n'utilise pas vraiment C ++ mais si C # avait des amis, je le ferais au lieu du modificateur interne global d'assemblage , que j'utilise beaucoup. Cela ne rompt pas vraiment l'incapsulation, car l'unité de déploiement dans .NET est un assemblage.

Mais il y a ensuite l' attribut InternalsVisibleTo (otherAssembly) qui agit comme un mécanisme ami de l' assemblage croisé . Microsoft l'utilise pour les assemblages de concepteurs visuels .

Les amis sont également utiles pour les rappels. Vous pouvez implémenter des rappels en tant que méthodes statiques

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

où les callbackappels en localCallbackinterne, et le clientDatacontient votre instance. À mon avis,

ou...

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

Cela permet à l'ami d'être défini uniquement dans le cpp en tant que fonction de style c, et non d'encombrer la classe.

De même, un modèle que j'ai vu très souvent est de mettre tous les membres vraiment privés d'une classe dans une autre classe, qui est déclarée dans l'en-tête, définie dans le cpp et friended. Cela permet au codeur de cacher une grande partie de la complexité et du fonctionnement interne de la classe à l'utilisateur de l'en-tête.

Dans l'en-tête:

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

Dans le cpp,

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

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

Il devient plus facile de cacher des choses que l'aval n'a pas besoin de voir de cette façon.