Hoi Dricus,
Dank voor de snelle tip, ik heb het nu aan de praat met dit singleton design pattern.
Als ik watch zet op EngineSingleton::pEng, zie ik dat de pointer eerst nul is. Maak ik een CRandom object aan, dan krijgt hij een waarde. Als de CRandom instantie uit scope gaat en dus gedestruct wordt behoud de pointer zijn waarde en bij instantie van een later CRandom object point de pointer nog steeds naar hetzelfde geheugenadres. Het geheel lijkt dus te werken.
Wel heb ik de standaard implementatie iets aangepast, mijn instance() (eng()) returned geen pointer naar de class zelf, maar naar de engine class. Is dit goed?
Verder moet ik een delete op de pointer zetten die aan het einde van het programma vanzelf aangeroepen wordt. Hoe doe ik dat? Een boost::shared_ptr ipv boost::mt19937* op de eerste implementatie regel, of gaat de refcount daarvan niet naar 0 aan het einde van de main functie omdat hij static is? (note: ik ben niet echt bekend met de boost:shared_ptr.
De meest zinnige tekst die ik tegenkwam was
http://www.research.ibm.com/designpatterns/pubs/ph-jun96.txt, zie de drie paragrafen onder de eerste twee blokken code. Maar dit is wel erg oud. De boost:shared_ptr is toch een betere en meer bruikbare versie van de std::auto_ptr waar ze het in de tekst over hebben?
edit:
Hmm, na wat meer gelezen te hebben lijkt een shared_ptr me overkill. Ik moet een boost::scoped_ptr gebruiken. Mijn engine zal nooit van owner veranderen, en altijd maar een owner hebben: alleen die ene singleton class. Het enige wat ik nodig heb is dat de resource waar de pointer naar wijst automatisch weggegooit wordt.
Ik ga maar eens de destructor van die enigine tijdelijk aanpassen om te kijken of al dit gedoe uberhaupt nodig is, misschien is MSVC slim genoeg om dit zelf te doen en hoef ik geen smart pointers te gebruiken. Aan de andere kant zal ik het denk ik toch doen, zodat met een blik op de code duidelijk is dat we ons geen zorgen hoeven te maken over resource leaks.
C++:
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
69
70
71
72
73
74
75
76
77
78
79
80
81
| #pragma once
// includes
#include <boost/random.hpp>
#include <time.h>
// declaration
template<class Dist>
class CRandom
{
public:
/** use for Dist:
CRandomI Ci(min,max); uses uniform_int<int> - integral types
CRandomR Cr(min,max); uses uniform_real<double> - floating point types
for other ditributions or types, use:
CRandom<distribution<optional type>> Cr(0--3 params, depending on distribution);
for distributions and params, see: http://www.boost.org/doc/libs/1_39_0/libs/random/random-distributions.html
*/
// forwarding constructors
explicit CRandom()
: Gen(*EngineSingleton::Eng(), Dist())
{ }
template<class P>
explicit CRandom(const P & p1)
: Gen(*EngineSingleton::Eng(), Dist(p1))
{ }
template<class P>
explicit CRandom(const P & p1, const P & p2)
: Gen(*EngineSingleton::Eng(), Dist(p1, p2))
{ }
template<class P>
explicit CRandom(const P & p1, const P & p2, const P & p3)
: Gen(*EngineSingleton::Eng(), Dist(p1, p2, p3))
{ }
~CRandom(void) {};
typedef typename Dist::result_type result_type;
result_type operator()() { return Gen(); }
template<class T>
result_type operator()(T value) { return Gen(value); }
private:
boost::variate_generator<boost::mt19937,Dist> Gen;
};
// end declaration
// shorthand typedefs
typedef CRandom<boost::uniform_int<int>> CRandomI; // even int is default type , specify it in case it ever changes
typedef CRandom<boost::uniform_real<double>> CRandomR; // even double is default type, specify it in case it ever changes
/** engine wrapper class following singleton pattern, so every instantiation
of CRandom uses the same engine
based on: http://www.aristeia.com/Papers/DDJ_Jul_Aug_2004_revised.pdf
*/
// declaration
class EngineSingleton {
public:
static boost::mt19937* Eng();
protected:
EngineSingleton();
private:
static boost::mt19937* pEng;
};
// end declaration
// implementation
boost::mt19937* EngineSingleton::pEng = NULL;
boost::mt19937* EngineSingleton::Eng() {
if (pEng == NULL) {
pEng = new boost::mt19937(unsigned int(time(NULL)));
}
return pEng;
}
// end implementation |
[
Voor 13% gewijzigd door
TheWickedD op 24-07-2009 14:21
. Reden: auto_ptr stukje toegevoegd; scoped_ptr toegevoegd ]
/u/47683/Asterix%252060x60.png?f=community)
:strip_icc():strip_exif()/u/12461/crop65b195553d948.jpg?f=community)
:strip_icc():strip_exif()/u/35767/images.jpg?f=community)
.