MFC Projekt und template Unklarheit

Gast #3335915
Lesenswert?
• ▲
▼
Hiho,
ich bin gerade an einem altem Projekt, welches Großteil nicht aus meiner 
Feder stammt. Ein Gebilde macht mir Kopfschmerzen und ich wäre dankbar, 
wenn mal jemand rüberschaut.
Es handelt sich um ein MFC Projekt unter Visual Studio 6.0 und ich bin 
sehr unsicher um die Verwendung der Template Klasse AUTO_REF. Wie weiter 
unten zu sehen, werden Objekte auf dem Heap erzeugt, aber niemals 
gelöscht. Oder sehe ich irgendwas nicht .......
Danke im voraus Jean :)
1
//AUTO_REF Class defintion
2
template <typename T>
3
class AUTO_REF {
4
private:
5
   long *m_ref_p;
6
   T *m_inst_p;
7

8
public:
9
   AUTO_REF(T *inst_p = 0) : m_inst_p(inst_p) {  //>x
10
      m_ref_p = (long *) g_the_auto_ref_pool.malloc();
11
      *m_ref_p = 1;
12
   }
13

14
   AUTO_REF(const AUTO_REF<T> &other) : m_ref_p(other.m_ref_p), 
15
      m_inst_p(other.m_inst_p) {  //NOTHROW
16

17
      InterlockedIncrement(m_ref_p);
18
   }
19

20
   ~AUTO_REF() {  //NOTHROW
21
      if (!InterlockedDecrement(m_ref_p)) {
22
         delete m_inst_p;
23
         g_the_auto_ref_pool.free(m_ref_p);
24
      }
25
   }
26

27
   AUTO_REF &operator=(const AUTO_REF<T> &rhs) {  //NOTHROW
28

29
      AUTO_REF<T> temp(rhs);
30
      swap(temp);
31

32
      return *this;
33
   }
34

35
   T &operator*() const {     //NOTHROW
36
      return *m_inst_p;
37
   }
38

39
   T *operator->() const {    //NOTHROW
40
      return m_inst_p;
41
   }
42

43
   operator bool() const {    //NOTHROW
44
      return m_inst_p != 0;
45
   }
46

47
   T *get() const {           //NOTHROW
48
      return m_inst_p;
49
   }
50

51
   void swap(AUTO_REF<T> &other) {   //NOTHROW
52
      std::swap(m_ref_p, other.m_ref_p);
53
      std::swap(m_inst_p, other.m_inst_p);
54
   }
55

56
};//AUTO_REF

in Header
1
  typedef AUTO_REF<fltTrack> apfltTrack;

in Cpp
1
apfltTrack fltTrkList::load(const myString& fileName, bool append)
2
{
3

4
  if (!append ) {clear();}
5

6
  {
7
    apfltTrack track = new fltTrack(-1, fltTrack::UNKNOWN_FORMAT,   d_mapContainer);
8
    if ( track->loadFile(fltTrack::NMEA, fltTrack::BOAT, fileName, _T(""))) 
9
    {
10
        //Do something
11
        return track;
12
    }
13
  }
14

15
  {
16
    apfltTrack track = new fltTrack(-1, fltTrack::UNKNOWN_FORMAT,   d_mapContainer);
17
    if ( track->loadFile(fltTrack::NMEA, fltTrack::BOAT, fileName, _T(""))) 
18
    {
19
        //Do something
20
        return track;
21
    }
22
  }
23

24
  {
25
    apfltTrack track = new fltTrack(-1, fltTrack::UNKNOWN_FORMAT,   d_mapContainer);
26
    if ( track->loadFile(fltTrack::NMEA, fltTrack::BOAT, fileName, _T(""))) 
27
    {
28
        //Do something
29
        return track;
30
    }
31
  }
32

33
  {
34
    apfltTrack track = new fltTrack(-1, fltTrack::UNKNOWN_FORMAT,   d_mapContainer);
35
    if ( track->loadFile(fltTrack::NMEA, fltTrack::BOAT, fileName, _T(""))) 
36
    {
37
        //Do something
38
        return track;
39
    }
40
  }
41
  
42
  return 0;
43
}
#3336001
Lesenswert?
• ▲
▼
Jean Player schrieb:

> unten zu sehen, werden Objekte auf dem Heap erzeugt, aber niemals
> gelöscht. Oder sehe ich irgendwas nicht .......

Das ist ein 'Spezial-Pointer' der mitzählt, wie oft das von ihm 
verwaltete dynamisch erzeugte Objekt referenziert ist. Wenn es keine 
Referenz mehr darauf gibt, löscht er das Objekt dann hier
1
   ~AUTO_REF() {  //NOTHROW
2
      if (!InterlockedDecrement(m_ref_p)) {
3
         delete m_inst_p;             // <---------------
4
         g_the_auto_ref_pool.free(m_ref_p);
5
      }
6
   }

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren