Discussion :

[deubelte]

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

[koala01]

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

[deubelte]

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