Hylvenir
Messages postés364Date d'inscriptionmercredi 11 février 2004StatutMembreDernière intervention 5 octobre 2006
-
8 mars 2004 à 11:11
Cyberboy2054
Messages postés173Date d'inscriptionjeudi 20 décembre 2001StatutMembreDernière intervention22 août 2008
-
10 mars 2004 à 16:22
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
Cyberboy2054
Messages postés173Date d'inscriptionjeudi 20 décembre 2001StatutMembreDernière intervention22 août 2008 10 mars 2004 à 16:22
Lut
Par rapport a la remarque concernant iostream et stdio, c est une question de gout, personnellement ca ne me dérange absolument pas de faire des printf dans quelque chose fait en c++ (et qui ne peut, comme ici, pas etre porté vers du c (du moins je ne crois pas))
La remarque concernant le renvoie d une variable statique au l ieu d utiliser une methode statique me semble meilleure, je vais garder celle la. Néanmoins cette version portera probleme lors de l utilisation du multi threading (pas dans mon cas, car je ne m en sers pas), je ne sais pas si les methodes statiques sont sources de problemes si elles sont utilisées en multithreading
Et juste une question relative aux templates : qu elle est la difference entre
template < class T > class truc {....}; et
template < typename T > class truc {....}; ?
Car bien que je me serve des template depuis un moment, je n ai pas vraiment saisi la différence ....
A+
Hylvenir
Messages postés364Date d'inscriptionmercredi 11 février 2004StatutMembreDernière intervention 5 octobre 20062 8 mars 2004 à 20:46
BlackGoddess:
class Singleton
{ public: static Singleton& Instance(); };
// Il faut mettre les constructeurs en privé ici
Singleton& Singleton::Instance() {
static Singleton s;
return s;
}
Il faut utiliser de préférence une méthode statique de classe, cela
permet d'éviter des problèmes sur l'ordre de création des singletions.
Cette version doit marcher dans les cas simples.
(C'est la version de Scott Meyers sauf erreur de ma part)
La version postée utilise les templates qui est une forme un peu plus avancée
pour les singletons qui permettrait de gérer par les références mortes,
le multi-thread par exemple.
cs_Kirua
Messages postés3006Date d'inscriptiondimanche 14 avril 2002StatutMembreDernière intervention31 décembre 2008 8 mars 2004 à 16:35
BlackGoddess, je suis pas tt à fait sûr que ton option fonctionne dans le cas où tu voudrais utiliser proprement le singleton dans des classes sensées être réutilisables, si? je sais pas trop, mais ça me paraît trop simple (c'est pas un critère évidemment...)
BlackGoddess
Messages postés338Date d'inscriptionjeudi 22 août 2002StatutMembreDernière intervention14 juin 2005 8 mars 2004 à 12:09
juste pour info :
#include <stdio.h> est un header C
#include est l'equivalent C+
printf est du C, cout est du C++
on ne peut pas utiliser ca pour un singleton ? :
class singleton
{
...
};
class utilise_singleton
{
static singleton s;
...
};
static utilise_singleton::singleton s;
Hylvenir
Messages postés364Date d'inscriptionmercredi 11 février 2004StatutMembreDernière intervention 5 octobre 20062 8 mars 2004 à 11:11
Salut,
quelques remarques...
Ta classe ressemble plus à un conteneur
de singleton qu'à un singleton (cf Modern C++ Design)
Si tu ajoutes { CTest c = *a; }
après b = CTest :: GetInstance ();
ton programme ne devrait pas fonctionner (core)
Voici une version sans pointeur :
template< typename T >
T& SingletonHolder<T>::Instance()
{
if ( !instance_ )
instance_ = new T;
return *instance_;
}
template< typename T >
T* SingletonHolder<T>::instance_ = 0;
// Fonction principale
int main( int argc, char *argv[] )
{
CTest& a = SingletonHolder< CTest >::Instance(),
& b = SingletonHolder< CTest >::Instance();
... idem pour la suite
}
C'est du rapidement fait, ton y'a peut être d'autres bugs.
10 mars 2004 à 16:22
Par rapport a la remarque concernant iostream et stdio, c est une question de gout, personnellement ca ne me dérange absolument pas de faire des printf dans quelque chose fait en c++ (et qui ne peut, comme ici, pas etre porté vers du c (du moins je ne crois pas))
La remarque concernant le renvoie d une variable statique au l ieu d utiliser une methode statique me semble meilleure, je vais garder celle la. Néanmoins cette version portera probleme lors de l utilisation du multi threading (pas dans mon cas, car je ne m en sers pas), je ne sais pas si les methodes statiques sont sources de problemes si elles sont utilisées en multithreading
Et juste une question relative aux templates : qu elle est la difference entre
template < class T > class truc {....}; et
template < typename T > class truc {....}; ?
Car bien que je me serve des template depuis un moment, je n ai pas vraiment saisi la différence ....
A+
8 mars 2004 à 20:46
class Singleton
{ public: static Singleton& Instance(); };
// Il faut mettre les constructeurs en privé ici
Singleton& Singleton::Instance() {
static Singleton s;
return s;
}
Il faut utiliser de préférence une méthode statique de classe, cela
permet d'éviter des problèmes sur l'ordre de création des singletions.
Cette version doit marcher dans les cas simples.
(C'est la version de Scott Meyers sauf erreur de ma part)
La version postée utilise les templates qui est une forme un peu plus avancée
pour les singletons qui permettrait de gérer par les références mortes,
le multi-thread par exemple.
8 mars 2004 à 16:35
8 mars 2004 à 12:09
#include <stdio.h> est un header C
#include est l'equivalent C+
printf est du C, cout est du C++
on ne peut pas utiliser ca pour un singleton ? :
class singleton
{
...
};
class utilise_singleton
{
static singleton s;
...
};
static utilise_singleton::singleton s;
8 mars 2004 à 11:11
quelques remarques...
Ta classe ressemble plus à un conteneur
de singleton qu'à un singleton (cf Modern C++ Design)
Si tu ajoutes { CTest c = *a; }
après b = CTest :: GetInstance ();
ton programme ne devrait pas fonctionner (core)
Voici une version sans pointeur :
// ----- SingletonHolder
template< typename T >
class SingletonHolder
{
protected:
SingletonHolder();
SingletonHolder( const SingletonHolder& );
~SingletonHolder() { delete instance_; }
SingletonHolder& operator == ( const SingletonHolder& );
static T* instance_;
public:
static T& Instance();
};
template< typename T >
T& SingletonHolder<T>::Instance()
{
if ( !instance_ )
instance_ = new T;
return *instance_;
}
template< typename T >
T* SingletonHolder<T>::instance_ = 0;
// Fonction principale
int main( int argc, char *argv[] )
{
CTest& a = SingletonHolder< CTest >::Instance(),
& b = SingletonHolder< CTest >::Instance();
... idem pour la suite
}
C'est du rapidement fait, ton y'a peut être d'autres bugs.