IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C++ Discussion :

déclaration friend et héritage


Sujet :

C++

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre éprouvé
    Inscrit en
    Novembre 2006
    Messages
    1 073
    Détails du profil
    Informations forums :
    Inscription : Novembre 2006
    Messages : 1 073
    Par défaut déclaration friend et héritage
    bonjour
    comme vous pouvez le voir dans ce lien, il y a le code que j'ai reproduit ci dessous:

    http://come-david.developpez.com/tut...e=Singleton#L2

    Dans ce code, on a une clase SoundManager qui hérite d'un classe template Singleton<SoundManager>.

    Mais on voit aussi que cette classe est déclarée comme friend.

    Alors je me demandais à quoi cela pouvait bien servir de déclarer une classe friend que l'on hérite??
    Merci

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
     
     
    template <class T> class Singleton
    {
     
    public:
    	static T& Instance();
    protected:
    	static T m_i;
     
    private:
            T& operator= (const T&){}
    };
     
    class SoundManager :public Singleton<SoundManager>
    {
    friend class Singleton<SoundManager>;
     
    private:
     
    SoundManager(const SoundManager&){}
    SoundManager();
    ~SoundManager();
    };

  2. #2
    Expert éminent
    Avatar de koala01
    Homme Profil pro
    aucun
    Inscrit en
    Octobre 2004
    Messages
    11 644
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 53
    Localisation : Belgique

    Informations professionnelles :
    Activité : aucun

    Informations forums :
    Inscription : Octobre 2004
    Messages : 11 644
    Par défaut
    Salut,

    A vrai dire, il y a quelques erreur dans ton modèle de classe Singleton:

    L'opérateur d'affectation doit être déclaré (en accessibilité privée), mais non défini, tout comme devrait l'être le constructeur par copie (un singleton ne pouvant être ni assigné ni copié).
    De plus, le constructeur et le destructeur du singleton devrait, eux aussi, être déclarés dans l'accessibilité privée (de manière à ce que ces fonctions ne soient pas accessibles depuis l'interface publique).
    Enfin, il est inutile de déclarer un objet de type singleton dans ce dernier: il "suffit" de le faire directement dans la fonction instance.

    Au final, ta classe Singleton devrait ressembler à:
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    template <class T> class Singleton
    {
        public:
            static T& Instance()
            {
                static Singleton<T> inst;
                return inst;
            }
     
     
    private:
            /* empêcher d'invoquer le constructeur et le destructeur en dehors
             * des fonctions propres au singleton
             */
            Singleton(){}
            ~Singleton(){}
            /* interdire l'affectation et la copie 
             * En attendant le = delete apporté par C++11, on déclare
             * les fonctions sans les définir
             */
            Singleton& operator= (Singleon const &); //déclaré, non défini
            Singleton(Singleton const &) // déclaré, non défini
     
    };
    ou, éventuellement (selon l'utilisation qui pourra en être faite)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    template <class T> class Singleton
    {
        public:
            static TSingleton & Instance()
            {
                if(!inst)
                    inst = new TSingleton;
            }
            static void destroy()
            {
                delete inst;
                inst = NULL
            }
     
    private:
            /* empêcher d'invoquer le constructeur et le destructeur en dehors
             * des fonctions propres au singleton
             */
            Singleton(){}
            ~Singleton(){}
            /* interdire l'affectation et la copie 
             * En attendant le = delete apporté par C++11, on déclare
             * les fonctions sans les définir
             */
            Singleton& operator= (Singleon const &); //déclaré, non défini
            Singleton(Singleton const &) // déclaré, non défini
            Singleton * inst;
     
    };
    template< class T>
    TSingleton<T> * TSingleton<T>::inst = NULL;
    Cependant, cela pose un problème au niveau de l'héritage: le constructeur de ton SoundManager doit... pouvoir accéder au constructeur de la classe de base.

    L'amitié déclarée permet donc à SoundManager d'accéder aux éléments déclarés dans l'accessibilité privée de Singleton<SoundManager>, et principalement, au constructeur et au destructeur, qui doivent être accessibles aux fonctions respectives de SoundManager, sans que ces fonctions ne doivent être exposées de manière moins restrictives

    Les raisons de faire de la sorte sont entre autre expliquées par l'entrée les amis brisent-ils l'encapsulation
    A méditer: La solution la plus simple est toujours la moins compliquée
    Ce qui se conçoit bien s'énonce clairement, et les mots pour le dire vous viennent aisément. Nicolas Boileau
    Compiler Gcc sous windows avec MinGW
    Coder efficacement en C++ : dans les bacs le 17 février 2014
    mon tout nouveau blog

  3. #3
    Membre éprouvé
    Inscrit en
    Novembre 2006
    Messages
    1 073
    Détails du profil
    Informations forums :
    Inscription : Novembre 2006
    Messages : 1 073
    Par défaut
    D'une manière générale, dans quel cas avons nous besoin d'une classe qui hérite d'une autre mais qui possède aussi une donnée membre de cette classe héritée.

    on a quelque chose comme:

    class A{}
    class B:public A{private: A a;};

    En fait B possède à la fois la relation "est un" et "est implémentée en terme de".
    J'aimerais bien avoir un cas simple qui illustre ce cas.
    merci

Discussions similaires

  1. Héritage et déclaration de variable
    Par sheridan08 dans le forum Débuter avec Java
    Réponses: 12
    Dernier message: 21/08/2012, 12h18
  2. Réponses: 0
    Dernier message: 01/07/2009, 09h33
  3. class friend et héritage
    Par camboui dans le forum Langage
    Réponses: 11
    Dernier message: 20/04/2009, 12h57
  4. Casse tête sur du friend avec de l'héritage
    Par Drannor dans le forum C++
    Réponses: 4
    Dernier message: 03/10/2007, 22h20
  5. [Héritage] Déclaration d'une classe amie
    Par nihlstroem dans le forum Delphi
    Réponses: 3
    Dernier message: 11/08/2006, 16h57

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo