Discussion :

[SofEvans]

Bonjour,

Tout dabord, je vous explique mon contexte.

J'ai creer une class "Ressource". Elle n'a qu'une seule et unique instance.
Cette instance est appelé un peu partout, mais après plusieurs fonctions.

C'est a dire que par exemple, on a trois fonction (a, b et c, soyons original).
La fonction "a" est appeler dans le main.
La fonction"a" appel la fonction "b".
La fonction "b" appel la fonction "c".

Et c'est dans la fonction "c" que j'ai réellement besoin de cette instance.
Dans l'etat actuel des choses, je dois passer mon instance par reference dans les parametre de "a", "b" et "c" afin de pouvoir l'utiliser dans "c".

J'utilise la SDL, et dans une fonction de la SDL, il y a SDL_GetVideoSurface.
Cette fonction retourne un pointeur vers l'ecran. Du coup, on a plus besoins de passer l'ecran par parametre a plein de fonction.

Ce que je voudrais faire, c'est une fonction comme SDL_GetVideoSurface qui retournerer mon instance de ressource afin de ne plus la trimballer a travers trois fonctions.

Si vous aviez des piste ou si vous savez comment faire, je suis preneur car je ne sais pas du tout comment faire ceci.

Merci de votre lecture.

[Le Mérovingien]

Salut,

La description de ton problème ressemble au cas d'utilisation d'un singleton :

- Ton objet est unique
- Il est appelé plein de fois dans des endroits différents

Tu peux regarder ce post (récent ) pour savoir si un singleton serait une bonne solution pour toi : http://www.developpez.net/forums/d78...re-singletons/
Si oui, tu trouveras plein de doc dessus, sur le site developpez.com en particulier :
http://come-david.developpez.com/tut...page=Singleton
mais il y'en a d'autres.


Tu as aussi ce post qui ressemble peut etre à ton problème :
http://www.developpez.net/forums/d60...leton-pattern/

[SofEvans]

Merci de ta réponse.

J'avais déjà lu qu'un singleton pourrait convenir mais étant donnée que c'est une sorte de variable global, j'espérai éviter.

J'essaye aussi de savoir comment fonctionne SDL_GetVideoSurface car c'est vraiment une fonction comme celle-ci que je voudrais coder.

[Le Mérovingien]

Salut,

Pour SDL_GetVideoSurface ils utilisent une variable globale, comme tu peux le voir ici : http://www.libsdl.org/cgi/viewvc.cgi....c?view=markup

Les variables globales, il faut s'en méfier c'est vrai, mais parfois c'est justifier de les utiliser.

Bon courage en tout cas

[SofEvans]

Merci beaucoup pour le lien ! (j'ai pas arreter de le chercher, mais je devais pas taper les bon mots ...).

Bon, tant pis pour la solution miracle, il semblerait que le singleton soit indiqué dans mon cas.

Merci pour tes lien et tes reponse.

[SofEvans]

Bonjour.

Je me permet de réouvrir le sujet.
Précédemment à ce que l'on m'a conseillé, je me suis diriger vers le singleton.

Etant donné que je ne m'intéresse ni au template, ni aux heritage, je me suis arreté a ce code :

class du singleton :

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
class CSingleton
{
    protected:
    int value;
    static CSingleton *singleton;
 
    //le constructeur privé
    CSingleton() : value(0)
    {
        cout<<"Singleton crée"<<endl;
    }
 
    //le destructeur privé
    ~CSingleton()
    {
        cout<<"Singleton détruit"<<endl;
    }
 
    public: 
 
    //un couple d'accesseur / mutateur    
    int GetValue()
    {
        return  value;
    }
 
    void SetValue(int val)
    {
       value=val;
    }
 
    //le "constructeur" public
    static CSingleton* GetInstance()
    {
        if(singleton==0)
        {
            singleton=new CSingleton;
        }
        return singleton;
    }
 
    //le "destructeur" public
    static void Kill()
    { 
 
        if(singleton!=0)
        {
            delete singleton;
            singleton=0;
        }
    }
 
 
};
 
CSingleton *CSingleton::singleton = 0;

main

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
 
#include <iostream>
 
using namespace std;
 
int main(void)
{
    CSingleton *obj1,*obj2;
 
    obj1=CSingleton::GetInstance();
    obj2=CSingleton::GetInstance();
 
    obj1->SetValue(5);
 
    cout<<obj1->GetValue()<<endl;
    cout<<obj2->GetValue()<<endl;
 
    cout<<obj1<<endl;
    cout<<obj2<<endl;
 
    CSingleton::Kill();
}

A partir de la, je me suis fais un test :

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
32
33
 
#ifndef SINGLETON
#define SINGLETON
 
#include <iostream>
 
class CSingleton
{
    protected:
    int value;
 
    static CSingleton *singleton;
 
    //le constructeur privé
    CSingleton();
 
    //le destructeur privé
    ~CSingleton();
 
    public:
 
    //un couple d'accesseur / mutateur
    int GetValue();
    void SetValue(int val);
 
    //le "constructeur" public
    static CSingleton* GetInstance();
 
    //le "destructeur" public
    static void Kill();
};
 
#endif

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include "Singleton.hpp"
 
using namespace std;
 
//le constructeur privé
CSingleton::CSingleton()
{
    value = 0;
    cout<<"Singleton crée"<<endl;
}
 
//le destructeur privé
CSingleton::~CSingleton()
{
    cout<<"Singleton détruit"<<endl;
}
 
//un couple d'accesseur / mutateur
int CSingleton::GetValue()
{
    return  value;
}
 
void CSingleton::SetValue(int val)
{
    value=val;
}
 
//le "constructeur" public
CSingleton* CSingleton::GetInstance()
{
    if(singleton==0)
        singleton = new CSingleton;
 
    return singleton;
}
 
//le "destructeur" public
void CSingleton::Kill()
{
    if(singleton!=0)
    {
        delete singleton;
        singleton=0;
    }
}
 
CSingleton *CSingleton::singleton = 0;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
#include "Singleton.hpp"
 
void FonctionTestSingleton(void);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
#include "Fonction A.hpp"
 
 
void FonctionTestSingleton(void)
{
    CSingleton *obj1 = CSingleton::GetInstance();
 
    obj1->SetValue(12);
}

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
 
#include <iostream>
 
#include "Singleton.hpp"
#include "Fonction A.hpp"
 
using namespace std;
 
 
int main()
{
    CSingleton *obj1 = CSingleton::GetInstance();
 
    obj1->SetValue(5);
 
    cout << obj1->GetValue() << endl;
 
    FonctionTestSingleton();
 
    cout << obj1->GetValue() << endl;
 
    CSingleton::Kill();
}

Désolé si j'ai mis tout mon code, je voulais qu'on soit d'accord.

J'ai lu qu'un singleton était une variable global.

A la fin de Singleton.cpp, il y a
CSingleton *CSingleton::singleton = 0;

singleton est donc cette variable global (si je ne m'abuse).

Cependant, singleton est un pointeur vers CSingleton (non ?), alors pourquoi l'initialiser a 0 et non a NULL ???

De plus, cette variable globale est definie a la fin de Singleton.cpp.
J'ai un peu de mal a visualiser sa porté.
Est-ce que singleton sera une variable global a chaque fichier ou l'en-tete #include "Singleton.cpp" sera ?
Est-ce que a chaque fois que j'ecrirais #include "Singleton.cpp", la variable singleton sera t'elle remise a zero ?