Singleton RenderWindow

[Xnerdz]

Bonjour.

J'aimerais faire un singleton qui contient ou hérite d'un RenderWindow.
Il semblerait que je ne puisse pas le déclarer en static 

Ça fait déjà plusieurs heurs que je travail la dessus et il semble que le seul moyen d'y parvenir est de déclarer le singleton en pointeur tout comme le renderwindow d'ailleur, et de les allouer ensuite après l'initialisation du main.

Mon problème est que j'ai besoin de ce singleton pour avoir tous mes points dans mon travail scolaire et que je ne peux pas utiliser la technique des pointeurs mentionnés, car il faut alors créé une sorte de methode "destroy" pour aller "delete" le singleton à la fin du programme et ce n'est pas de la bonne programmation que dit mon prof de toute façon.

Comment dois-je créé mon singleton utilisant un RenderWindow? 

[lezebulon]

C'est quoi qui t'empêche de déclarer en static? A mon avis ça devrait être possible, poste-nous le code qui ne va pas

[Xnerdz]

Oui, j'avait oublier 

GameWindow.h

Code: [Sélectionner]

class GameWindow
{
public:
static GameWindow& GetInstance();

private:
GameWindow(void);
~GameWindow(void);
GameWindow(const GameWindow& _source);
GameWindow& operator = (const GameWindow& _source);

static GameWindow instance;
static sf::RenderWindow* screen;
};

GameWindow.cpp

Code: [Sélectionner]

#include "GameWindow.h"

GameWindow GameWindow::instance;

GameWindow::GameWindow(void)
{
this->screen = new sf::RenderWindow();
}

GameWindow::~GameWindow(void)
{
delete screen;
}

GameWindow& GameWindow::GetInstance()
{
return instance;
}

Que je mette "sf::RenderWindow* screen;" static ou non j'ai des problèmes...
Si j'le mets pas, j'ai une violation d'écriture dans mlock.
Si j'le met, j'ai des symboles externes non résolus.

[Koryushin]

En fait pour les attributs static, ils faut abord les initialiser en dehors des méthodes.
En début de ton fichier GameWindow.cpp ou il faut écrire :

sf::RenderWindow* GameWindow::screen = (sf::RenderWindow*)NULL;
GameWindow* GameWindow::instance =(GameWindow*)NULL;

en déclarant instance comme un pointeur dans le .h

[Xnerdz]

sf::RenderWindow* GameWindow::screen = (sf::RenderWindow*)NULL;
GameWindow* GameWindow::instance =(GameWindow*)NULL;

en déclarant instance comme un pointeur dans le .h

Mille fois merci! 

J'ai toutefois, un autre petit souci qui se crée alors.
Si j'utilise dynamiquement l'instance de mon singleton, je dois alors aussi le supprimer.
Ce que j'ai remarqué c'est que, quand je met un "break point" dans le destructeur de GameWindow, il n'est jamais lu.
Cela m'inquiète un peu, car delete instance; et delete screen; ne seront jamais appelé et... tu sait... les memory leeks... 

Est-ce que les classes static on besoin d'un destructeur? 

Bref, cela revient à mon problème de départ où je dois appeler le destructeur à la main et ça, ce n’est pas de la programmation conventionnelle.

[Laurent]

Tu peux utiliser la forme la plus simple du singleton, si ses inconvénients n'en sont pas pour toi (initialisation non thread-safe avec un compilo pre-C++11, destruction après la fin du main(), impossible de contrôler l'ordre si plusieurs singletons inter-dépendants).

class GameWindow
{
public:

    static GameWindow& GetInstance()
    {
        static GameWindow instance;
        return instance;
    }

    ...
};
 

Et pourquoi avoir un membre statique (autre que l'instance de la classe) dans une classe singleton ?

[Xnerdz]

class GameWindow
{
public:

    static GameWindow& GetInstance()
    {
        static GameWindow instance;
        return instance;
    }

    ...
};
 

Je vais essailler ça ce soir 

Et pourquoi avoir un membre statique (autre que l'instance de la classe) dans une classe singleton ?

Parce que j'ai pas dormit de la nuit? 

Merci pour les réponses rapides.

[lezebulon]

En fait le destructeur de ton object static est bien appellé, mais après le main.

@Laurent : c'est thread-safe de faire ça en C++11? Comment ça se fait ?

[Laurent]

@Laurent : c'est thread-safe de faire ça en C++11? Comment ça se fait ?

Parce qu'ils ont rajouté cette garantie dans le standard, tout simplement.

[Koryushin]

tu peux passer par une classe template pour créer ton singleton.

////////////////////////////////////////////////////////////
/// Template servant à construire les classes singleton
////////////////////////////////////////////////////////////
template <class T>
class CSingleton
{
public :

        //----------------------------------------------------------------
        // Renvoie l'instance unique de la classe
        //----------------------------------------------------------------
        static T* GetInstance()
        {
                if (!Inst)
                        Inst = new T;

                return Inst;
        }

        //----------------------------------------------------------------
        // Détruit l'instance unique de la classe
        //----------------------------------------------------------------
        static void Destroy()
        {
                delete Inst;
                Inst = NULL;
        }

protected :

        //----------------------------------------------------------------
        // Constructeur par défaut
        //----------------------------------------------------------------
        CSingleton() {}

        //----------------------------------------------------------------
        // Destructeur
        //----------------------------------------------------------------
        ~CSingleton() {}

private :

        //----------------------------------------------------------------
        // Données membres
        //----------------------------------------------------------------
        static T* Inst; ///< Instance unique de la classe

        //----------------------------------------------------------------
        // Copie interdite
        //----------------------------------------------------------------
        CSingleton(const CSingleton&);
        CSingleton& operator =(const CSingleton&);
};

template <class T> T* CSingleton<T>::Inst = (T*)NULL;


 

et ta classe GameWindow hérite de CSingleton de la maniere suivante

class GameWindow : public CSingleton<GameWindow >
{
   friend class CSingleton<GameWindow >;

   protected:

      GameWindow ();
      ~GameWindow();
    ...
};

 

[Xnerdz]

Merci pour toute ces réponses!

Code: [Sélectionner]

    static GameWindow& GetInstance()
    {
        static GameWindow instance;
        return instance;
    }


Laurent, j'ai essayé ça tantôt.
Petite question, est-ce que instance est alors réaffecté à chaque appel de GetInstance()?

En fait le destructeur de ton object static est bien appellé, mais après le main.

Vraiment? ça expliquerait pourquoi j'entre jamais dedans avec mon breakpoint.   
J'ai vérifié tout ça au Virtual Leek Detector et en effet, ya aucune fuite. 

Merci

Code: [Sélectionner]

template <class T>
class CSingleton
...
Mais la je vais plutôt opté pour une solution un peu plus simpliste.

[Laurent]

Petite question, est-ce que instance est alors réaffecté à chaque appel de GetInstance()?

Ben... non. Sinon ce serait un peu con, et surtout ce ne serait pas un singleton.
Tu ne connais pas les variables statiques de fonction ?

ça expliquerait pourquoi j'entre jamais dedans avec mon breakpoint.

Normalement ça ne gêne pas, le debugger ne s'arrête pas quand main() retourne.

[Xnerdz]

D’acore, merci pour tout.