Ist ja unglaublich, dass man anhand vom singleton sehr viel lernen kann. Find das cool!
Ich verwende momentan folgenden Aufbau und hätte anschliessend dazu ne frage:
|
C-/C++-Quelltext
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
/* cTimeManager.h */
class cTimeManager
{
private:
static cTimeManager* m_ptrInstance;
cTimeManager(){} // Konstruktor
cTimeManager( const cTimeManager& ); // Kopierkonstruktor private, KEIN kopieren mehr möglich
public:
static cTimeManager* CreateInstance();
static cTimeManager* GetInstance();
HRESULT Destroy();
~cTimeManager(){ Destroy(); }
};
|
|
C-/C++-Quelltext
|
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
|
/* cTimeManager.cpp */
//-----------------------------------------------------------------------------
// STATIC Pointer auf einzige Objektinstanz
//-----------------------------------------------------------------------------
cTimeManager* cTimeManager::m_ptrInstance = NULL;
//-----------------------------------------------------------------------------
// Name: CreateInstance()
// Desc: Eine neue, einmalige Objektinstanz aus cTimeManager erstellen
// Dient zur Initialisierung
//-----------------------------------------------------------------------------
cTimeManager* cTimeManager::CreateInstance()
{
if( m_ptrInstance == NULL )
{
m_ptrInstance = new cTimeManager;
// neue Instanz retour
return m_ptrInstance;
}
// vorhandene Instanz retour
return m_ptrInstance;
}
//-----------------------------------------------------------------------------
// Name: GetInstance()
// Desc: Aktuelle Objektinstanz zurückliefern
// Dient zum vereinfachten Gebrauch -
// Objektinstanz braucht nicht überall als Parameter übergeben werden
//-----------------------------------------------------------------------------
cTimeManager* cTimeManager::GetInstance()
{
if ( m_ptrInstance )
{
return m_ptrInstance;
}
else
{
return NULL;
}
}
//-----------------------------------------------------------------------------
// Name: Destroy()
// Desc: Angeforderten Speicher sauber löschen
//-----------------------------------------------------------------------------
HRESULT cTimeManager::Destroy()
{
// Speicherbereich mit 0 auffüllen
// Pointer löschen
// Point-to Adresse löschen
if (m_ptrInstance)
{
SecureZeroMemory(&m_ptrInstance,sizeof(m_ptrInstance));
delete m_ptrInstance;
m_ptrInstance = NULL;
return S_OK;
}
// Keine Objektinstanz zum löschen vorhanden
// RETURN: Invalid_Pointer
return E_POINTER;
}
|
Die Grundstruktur stammt aus meinem Buch
"Design Patterns - Elements of Reuseable Object-Oriented Software"
Dort wurde allerdings kein Destruktor implementiert.
Somit hab ich das ganze nach eigenem Ermessen ausgebaut und mein
Programm läuft zur zeit sehr stabil.
|
C-/C++-Quelltext
|
1
2
|
static cTimeManager* CreateInstance();
static cTimeManager* GetInstance();
|
... verwende ich zur besseren Übersicht.
Dachte mir, wenn ich nur GetInstance() verwende, lässt sich
a) später im code schwer herausfinden, wo die Objektinstanz
eigentlich erzeugt wird und
b) kann ich bei der CreateInstance() nach belieben Parameter für die
Initialisierung mitgeben, die ich dann natürlich bei GetInstance
nicht mehr brauche.
Allerdings stell ich mir die Frage, warum der ganze Aufwand mit den
Singletons. Wenn ich zB. eine Klasse mit lauter STATIC-Methoden
machen würde, hätts doch den selben effekt oder?
@rklaffehn
Danke! Jetzt blick ich da durch
Was mir an der Diskutierten Variante sehr gefällt ist, dass die ganz
und gar ohne NEW auskommt.
Lohnt es sich, meinen Code auf diese Variante anzupassen?
(hab inzwischen schon 11 Singletons in meiner Anwendung...)