Variable accessible de partout

Version imprimable

31/07/2009, 02h09
SofEvans

Variable accessible de partout

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.
31/07/2009, 10h36
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 :D) 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/
31/07/2009, 12h02
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.
31/07/2009, 13h38
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 ;)
31/07/2009, 19h28
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.

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:

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:

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:

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:

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:

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

Code:

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:

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 ?

02/08/2009, 19h54
Davidbrcz

Ce tutoriels est le mien.

Sinon, une seule giga classe "Ressource", ca sent le problème de conception à plein nez (comprendre le manque d'analyse).
03/08/2009, 09h29
Le Mérovingien

Hello,

Pour ce qui est de ta variable globale singleton, ce n'en est pas une, c'est seulement l'initialisation d'une variable static dans une classe : C++ stipule que l'on doit initialiser les variables static à l'extérieur de la classe.
Etant donné que l'on écrit :

Code:

CSingleton *CSingleton::singleton = 0;

la variable singleton n'est accessible que dans la classe CSingleton (c'est ce que souligne le préfix "CSingleton::").
De plus, en C++ toujours, un pointeur null est initialisé à 0 et non à NULL, mais celà revient au même puisque je ne connais pas d'implémentation du C où NULL != 0. Je crois que dans la nouvelle norme C++ (C++0x pour l'instant), il y'aura une syntaxe pour les pointeurs null, ou pas...

Pour les éventuels problèmes de conception, je serais plutôt du même avis que Davidbrcz, mais n'étant pas très calé en la matière, je laisse à d'autres le soin de te conseiller :mrgreen:.