Discussion :

[Davidbrcz]

Bonjour a tous.
Suite à des recherches sur le patern (ou anti) singleton, j'ai pensé une chose.
Pourquoi ne pas globaliser des variables locales ?
Ca donnerai un truc du genre :

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
58
59
60
61
62
63
64
65
66
67
68
69
70
 
#include <iostream>
 
using namespace std;
 
template <class T> class Globalisator 
{
protected:
    static T* m_instance;
 
public:
    static T* GetInstance()
    {
        if(m_instance==0)
 
            throw; //ici trow seul pour dire que c'est pas bien de 
                   //ne pas initialiser.Il faudrai définir une 
                   // exeption perso.
        return m_instance;
    }
 
    static void SetInstance(T* inst)
    {
        m_instance=inst;
    }
 
    static void Release()
    {
        m_instance=0;
    }
};
 
template <class T> T* Globalisator<T>::m_instance=0;
 
//classe de test
//aucune utilité
class Test : public Globalisator<Test> 
{
    int m_i;
public:
    Test():m_i(0){};
    int Test2(){m_i++;return m_i;}
 
};
 
//fonction de test
//Réelle utiité dans des classes
void fct()
{
    cout<<Test::GetInstance()->Test2()<<endl;
 
}
int main (void)
{
    Test t1,t2;
 
//je fais ca sur des variables locales.
//Mais comme elles sont locales a main , c'est pas grave.
//le mieux serait de le faire sur des pointeurs alloué dynamiquement.
    Test::SetInstance(&t1); 
 
    fct();
    fct();
    Test::SetInstance(&t2);
    fct();
    Test::Release(); 
    fct(); //test du throw
 
    return 0;
}

De cette facon , on peut rendre globale une variable un temps donné en sachant où et quand le programeur détruit manuellemnt la donnée.

Je sais que mon truc c'est du singleton-like mais je tient quand même a dire que ce n'est un singleton,puisque on peut crée autant d'instance qu'on veut et que la classe na (logiquement) pas la gestion de la création et de la destruction des variables.

Alors qu'en pensez vous ?

Edit : existe un moyen d'empecher le destruction de la donnée si on fait un delete sur Test::GetInstance() ?

[HanLee]

Oula, je trouve que c'est encore pire que les variables globales...

Mal utilisé ça doit facilement rendre les erreurs encore plus difficiles à localiser dans ces cas-là, parce qu'il faut savoir qui a été appelé quand...

C'est typiquement le cas où tu veux paramétrer tes fonctions, non ?

[Davidbrcz]

Non, je pensais utilisé ca pour evitéer d'utiliser dle singleton dans un gestionaire dynamque d'event.
Mais sache que classe , c'est jsute une classe de test , il faudrai y ajouter un gestionaire de debug pour savoir quel pointeur est appelé, une vrai gestion des exeptions, ...

[Jean-Marc.Bourguet]

Ca ressemble à une utilisation du dynamic scoping dans certains dialectes de lisp, mais mieux contrôlée. Mais la plupart des lisp récents utilisent du lexical scoping, parce que justement ça pose des problèmes de maintenance. Le fait que ce soit mieux contrôlé diminue ces problèmes, mais je ne suis pas sûr que ce soit une bonne idée. Entre autres parce que le multi-tâches sous différentes formes se généralise de plus en plus -- et qu'est-ce qui se passe avec ton système en multi-thread?

[Davidbrcz]

Ca ressemble à une utilisation du dynamic scoping dans certains dialectes de lisp, mais mieux contrôlée. Mais la plupart des lisp récents utilisent du lexical scoping, parce que justement ça pose des problèmes de maintenance. Le fait que ce soit mieux contrôlé diminue ces problèmes, mais je ne suis pas sûr que ce soit une bonne idée.

J'ai pas tout compris (dynamic scoping ?).

Entre autres parce que le multi-tâches sous différentes formes se généralise de plus en plus -- et qu'est-ce qui se passe avec ton système en multi-thread?

Et multi thread , ca doit être le bordel , mais comme j'ai pas l'intention de toucher au threads,je m'en fout un peu .

Mais si un jours je doit utiliser ce code dans un environement MT , il suffirait(dite moi si je me trompe) de poser un mutex avant chaque appel de GetInstance et de le libérer quand on ne sert plus de pointeur donner par GetInstance.

[Jean-Marc.Bourguet]

J'ai pas tout compris (dynamic scoping ?).

En gros, l'équivalent de

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int var = 0;
int f() {
   printf("%d\n", var);
}
 
int main() {
   int var = 42;
   f();
}

Affiche 42.

Et multi thread , ca doit être le bordel , mais comme j'ai pas l'intention de toucher au threads,je m'en fout un peu .

Famous last words comme on dit en anglais.

Mais si un jours je doit utiliser ce code dans un environement MT , il suffirait(dite moi si je me trompe) de poser un mutex avant chaque appel de GetInstance et de le libérer quand on ne sert plus de pointeur donner par GetInstance.

Le problème c'est que deux threads vont vouloir avoir des valeurs différentes dans ta globale...

[Davidbrcz]

C'est bon , j'ai compris pour le dynamic scoping.

Apres si un jour je me met au MT ,comment résoudre cela ?
Ne pas utiliser des variables globales ?
Avoir une attente active(ou semi-active) ?

[Jean-Marc.Bourguet]

Apres si un jour je me met au MT ,comment résoudre cela ?
Ne pas utiliser des variables globales ?

Le MT est une des raisons qui font que le singleton est considéré par certains comme un anti-pattern. Tu peux chercher "parametrize from above pattern" pour une piste de solution.

Un système de variables propres aux threads peut aussi être une solution.

[Davidbrcz]

"parametrize from above pattern" sur google m'amène vers des truc en Java/C# inexploitable en C++ car il présente des constructeur statique ou autre joyeusté.
Mais je continue de charcher.

Un système de variables propres aux threads peut aussi être une solution.

Une classe commune qui contient toutes les données de la classe et autant de classes dérivées de cette et en même temps de globalisator qu'il faut de thread .
C'est lourd , c'est moche , ca pue mais ca marche.