MFC Projekt und template Unklarheit

[Jean Player (Gast)]

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 :)

//AUTO_REF Class defintion
template <typename T>
class AUTO_REF {
private:
   long *m_ref_p;
   T *m_inst_p;

public:
   AUTO_REF(T *inst_p = 0) : m_inst_p(inst_p) {  //>x
      m_ref_p = (long *) g_the_auto_ref_pool.malloc();
      *m_ref_p = 1;
   }

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

      InterlockedIncrement(m_ref_p);
   }

   ~AUTO_REF() {  //NOTHROW
      if (!InterlockedDecrement(m_ref_p)) {
         delete m_inst_p;
         g_the_auto_ref_pool.free(m_ref_p);
      }
   }

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

      AUTO_REF<T> temp(rhs);
      swap(temp);

      return *this;
   }

   T &operator*() const {     //NOTHROW
      return *m_inst_p;
   }

   T *operator->() const {    //NOTHROW
      return m_inst_p;
   }

   operator bool() const {    //NOTHROW
      return m_inst_p != 0;
   }

   T *get() const {           //NOTHROW
      return m_inst_p;
   }

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

};//AUTO_REF

in Header

  typedef AUTO_REF<fltTrack> apfltTrack;

in Cpp

apfltTrack fltTrkList::load(const myString& fileName, bool append)
{

  if (!append ) {clear();}

  {
    apfltTrack track = new fltTrack(-1, fltTrack::UNKNOWN_FORMAT,   d_mapContainer);
    if ( track->loadFile(fltTrack::NMEA, fltTrack::BOAT, fileName, _T(""))) 
    {
        //Do something
        return track;
    }
  }

  {
    apfltTrack track = new fltTrack(-1, fltTrack::UNKNOWN_FORMAT,   d_mapContainer);
    if ( track->loadFile(fltTrack::NMEA, fltTrack::BOAT, fileName, _T(""))) 
    {
        //Do something
        return track;
    }
  }

  {
    apfltTrack track = new fltTrack(-1, fltTrack::UNKNOWN_FORMAT,   d_mapContainer);
    if ( track->loadFile(fltTrack::NMEA, fltTrack::BOAT, fileName, _T(""))) 
    {
        //Do something
        return track;
    }
  }

  {
    apfltTrack track = new fltTrack(-1, fltTrack::UNKNOWN_FORMAT,   d_mapContainer);
    if ( track->loadFile(fltTrack::NMEA, fltTrack::BOAT, fileName, _T(""))) 
    {
        //Do something
        return track;
    }
  }
  
  return 0;
}

[Rufus Τ. F. (rufus)]

Jean Player schrieb:
> Oder sehe ich irgendwas nicht

Sieh Dir mal an, was g_the_auto_ref_pool macht.

Ich tippe stark auf ein automatisches Reference-Counting-Dingens.

Der Code scheint übrigens von hier
http://www.codeproject.com/Articles/1648/The-fastest-smart-pointer-in-the-west
zu stammen.

[Karl H. (kbuchegg)]

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

   ~AUTO_REF() {  //NOTHROW
      if (!InterlockedDecrement(m_ref_p)) {
         delete m_inst_p;             // <---------------
         g_the_auto_ref_pool.free(m_ref_p);
      }
   }

[Jean Player (Gast)]

Ahhhh, besten Dank Karl und Rufus.
Jetzt sehe ich klarer :)

Grüsse Jean :)