Quelques questions sur les design pattern
Bonjour,
Mes questions concernent les design montrés sur cette page.
Tout d'abord, commençons par le design pattern "Prototype" qui décrit le clonage.
Tout d'abord, n'est-il pas dangereux ici d'effectuer un new dans la classe et d'effectuer le delete en dehors de la classe ?
Tel que:
Code:
1
2
3
4
5
6
|
MySQLManager* MySQLManager::Clone() const
{
//le constructeur de recopie fait tout le travail à notre place.
return (new MySQLManager(*this));
} |
et
Code:
1
2
3
|
MySQLManager* manager2=manager1->Clone();
delete manager2; |
Personnellement, je trouve que cette méthode pas très propre, à savoir que selon moi, c'est l'instance qui a alloué la mémoire qui doit la libérer.
Aussi, pourquoi s'ennuyer à créer une méthode "clone" alors que le constructeur de copie par défaut ferait très bien le boulot ?
Code:
1
2
|
MySQLManager manager2 = manager1; |
est-il moins propre ?
Ensuite, toujours dans ce même design, l'utilisation des templates est-elle justifiée dans le but de généricité ? Personellement, je ne vois ce qu'apporte les templates de plus dans ce cas précis.
Ensuite, pour le design Singleton, je vais mettre un code et une citation pour que ça soit plus clair (du lien fournis plus haut):
Citation:
En effet, avec la classe singleton actuelle, il faut faire hériter de Singleton la classe que l'on souhaite avoir en unique exemplaire. Or la classe Singleton est template, le seul moyen de l'instancier est donc de passer la classe dérivée en paramètre de Singleton.
Code:
1
2
3
4
5
6
7
8
|
int main(void)
{
SoundManager* sin=Singleton<SoundManager>::Get();
SoundManager* sin2=Singleton<SoundManager>::Get();
std::cout<<sin<<"|"<<sin2<<std::endl;
Singleton<SoundManager>::Kill();
} |
Je ne comprends rien mais strictement rien.
En quoi cette écriture serait moins adaptée ? :
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
58
59
60
61
62
63
64
65
66
67
68
|
#include <iostream>
template< class T >
class Singleton
{
protected:
static T* m_instance;
public:
static T * const & Get()
{
if( !m_instance )
{
m_instance = new T();
}
return m_instance;
}
static void Kill()
{
delete m_instance;
m_instance = 0;
}
};
template <class T>
T* Singleton<T>::m_instance=0;
class SoundManager : public Singleton<SoundManager>
{
//...
std::string m_str;
friend SoundManager * const& Singleton<SoundManager>::Get();
friend void Singleton<SoundManager>::Kill();
SoundManager() :
m_str("Quelque chose")
{
std::cout << "Creation" << std::endl;
}
~SoundManager()
{
std::cout << "Destruction" << std::endl;
}
public:
void Do()
{
std::cout << m_str << std::endl;
}
};
int main()
{
typedef SoundManager * const & SoundManagerRefPtr;
SoundManagerRefPtr sin1 = SoundManager::Get();
sin1->Do();
SoundManagerRefPtr sin2 = SoundManager::Get(); // Pour montrer qu'il n'y a pas double création
std::cout << sin1 << " | " << sin2 << std::endl;
SoundManager::Kill();
std::cout << sin1 << " | " << sin2 << std::endl;
SoundManager::Kill(); // Pour montrer qu'il n'y a pas double destruction
return 0;
} |
J'ai d'autres questions en attente mais j'aimerais déjà avoir réponse à ceux-ci car je crois avoir zappé quelques trucs et donc ai un peu peur de l'idiotie de mes autres questions...
