Un chti exercice pour vous, que j ai deja demande a un test d embauche, donc ca pourra vous etre utile.

Il s´agit ici de creer un modele de singleton, parfaitement utilisable pour tous types d objets dans un programme. Ex de mauvais code:

class TextureMgr
{
public:

static TextureMgr& getInstance()
{
static TextureMgr s_mgr;
return s_mgr;
}

void printVersion( void ) { printf( " 1.0\n" ) ; }

private:
TextureMgr() {}
};

int main( int argc, char ** argv )
{
TextureMgr m1 = TextureMgr::getInstance();
TextureMgr m2 = TextureMgr::getInstance(); / / m1 == m2
m1.printVersion();
return 0;
}

Note: c´est marrant, mais j ai vu peu de personnes qui ont pu me donner un solution satisfaisante pour permettre de l heritage, etc..

ah ben tiens, c´est encore plus marrant que j´ai implémenté mon template de singleton y´a moins d´un mois :p
un joli template qu´il suffit de dériver ; tiens t´as gagné un mail. J´ai gagné qqch ? :D

Le droit de le poster la pour que j puisse mettre mes commentaires ; )

. .. on va encore croire que c´est un " hello world" dégueulasse... non non ; ) LOL

Pour faire un singleton faut preciser qqs trucs avant je pense.
Est-ce qu´on interdit la creation d´une nouvelle instance par le compilateur, ou bien a l´execution avec un msg d´erreur?
Si on permet de creer une instance, et qu´on en fait une 2eme, on renvoie la meme que la 1ere, ou bien message d´erreur?
Est-ce qu´on laisse l´utilisateur gerer la destruction de l´objet?

Je vais passer pour le noob de service : a quoi ça sert un singleton ?

t´inquiete moin aussi c quoi sngleton ( c pas un language de programation)

g tout comprit........

i_am_the_law: la est tout l´interet de la question, choisir ce qui pourra etre le plus utile, le plus adapte a un code professionel..

Oui, ça c sûr, même moi je comprends que ça c logique.

D´apres votre code au dirait que c´est une classe qui ne peut être instanciée
qu´une fois. ( je suis pas si noob que ça)
Ma question est donc toujours : a quoi ça sert ?

Je c pas :´(

C´est quoi un Singleton ?

Ok un singleton est une classe que l´on ne peut instancier qu une fois, mais en general recuperer un peu partout via un getter ou une autre technique.

A quoi ca sert? Ben tout s´implement a s´assurer qu´on instancie qu une seule fois cette classe, car il n´y a pas besoin de plusieurs instances..
Ex: texture manager, random generator, file manager, . .
Pourquoi ne pas avoir des fonctions statiques? Ben pour permettre une abstraction et l´heritage..

Oh voilà un sujet bien délicat . .. personnellement j´utilise la méthode présentée dans Game Programming Gems ( n°1) avec une petite correction, car celle du bouquin pose des problèmes de portabilité. D´ailleurs je la vois souvent utilisée un peu partout mais sans cette correction.

Je la poste ou pas ?

Moi j´utilise une version un peu modifiee de l´implementation " loki" presentee dans le livre modern c++ design ( ...)

http://sourceforge.net/projects/loki-lib/
J´ai enleve certaines de leur policies qui me semblaient un peu inutiles pour simplifier un peu le code, et rajouter des fonctionnalites dont j´avais besoin.

La version presentee dans game programing gems est bien ( malgre leur " hack" avec les calculs de pointeurs), mais il faut faire un new et un delete. Je sais pas si cette methode pourrait convenir dans un cadre professionnel ou on cherche surement a tout simplifier pour le programmeur lambda qui utilisera le code.

Justement le " hack" est le point sur lequel il faut faire attention ( et modifier). Ok je la poste ( désolé pour l´indentation) :

/ / Singleton class - original version by Scott Bilas ( Game Programming Gems)

Singleton.h :

template < typename T> class Singleton
{
private:
static T* ms_Singleton;

public:
Singleton()
{
assert(!ms_Singleton);
/ / Non portable
/ / int offset = ( int)(T*)1 - ( int)(Singleton < T>*)(T*)1;
/ / ms_Singleton = ( T*)((int)this + offset);
/ / Correction :
ms_Singleton = static_cast < T*> ( this);
}

~Singleton()
{
assert(ms_Singleton);
ms_Singleton = 0;
}

static T& GetSingleton()
{
assert(ms_Singleton);
return ( *ms_Singleton);
}

static T* GetSingletonPtr() { return ( ms_Singleton); }
};

template < typename T> T* Singleton < T>::ms_Singleton = 0;

Ensuite le new/delete n´est pas obligatoire tu peux t´en servir comme ceci :

Un manager quelconque :

Manager.h

class UnManager : public Singleton<UnManager>
{
. ..
}

1. ifdef _STATIC_SINGLETON

#define gManager UnManager::GetSingletonPtr()

1. else

extern UnManager *gManager;

1. endif

Manager.cpp :

1. ifdef _STATIC_SINGLETON

static UnManager gManager;

1. endif

L´utilisateur n´a alors pas besoin de se soucier du new/delete dans le cas de la version en statique.

J´aime bien cette methode, et qq un qui me presente ca le premier truc que je lui demande ce sont les avantages et les inconvenients.
Des inconvenients, il y en a: si je veux avoir une classe abstraite, par ex class Abstraite : public Singleton<Abstraite>, comment je fais au niveau de l´heritage?

Ensuite: pour ou contre avoir un constructeur public? Ne serait-il pas judicieux de l´avoir mis prive pour qu une deuxieme instanciation ne passe pas a la compilation?

Comment je fais si je veux passer des arguments differents a mes constructeurs, est-ce que ca marche? ( ici oui ca devrait)