Im der nächsten C++ Standard Library wird unter anderem die shared_ptr Klasse zur Verfügung stehen. Diese Template Klasse kapselt jeden beliebigen Pointer und übernimmt die Verwaltung dieser. Läuft einmal ein Pointer Out-of-Scope, bzw. wird nicht mehr referenziert, so wird Automatisch das entsprechende Objekt gelöscht und, falls vorhanden der Destruktor aufgerufen. Die entsprechenden Resourcen werden wieder freigegeben.

In der folgenden Beispielklasse werden zwei Strings allokiert und beim löschen der Instanz auch wieder freigegeben. Hier der Code:

   1: #include "StdAfx.h"
   2: #include "Employee.h"
   3:  
   4: Employee::Employee(void)
   5: {
   6:     this->lastname = new TCHAR[ 20 ];
   7:     this->firstname = new TCHAR[ 20 ];
   8:  
   9:     _tcscpy_s( this->lastname, 20, _T( "Parys" ) );
  10:     _tcscpy_s( this->firstname, 20, _T( "Dariusz" ) );
  11: }
  12:  
  13: Employee::~Employee(void)
  14: {
  15:     if( this->firstname != NULL )
  16:     {
  17:         delete this->firstname;
  18:     }
  19:     if( this->lastname != NULL )
  20:     {
  21:         delete this->lastname;
  22:     }
  23: }
  24:  
  25: TCHAR* Employee::GetFirstname()
  26: {
  27:     return this->firstname;
  28: }
  29:  
  30: TCHAR* Employee::GetLastname()
  31: {
  32:     return this->lastname;
  33: }

Nutzt man die Employee Klasse so werden jedesmal die zwei internen Member allokiert. Vergisst man hierbei die Klasse korrekt zu löschen, so entstehen Memory-Leaks. Hier ein Beispiel das einen Memory-Leak erzeugt:

   1: int _tmain(int argc, _TCHAR* argv[])
   2: {
   3:     {
   4:         Employee* emp = new Employee();
   5:  
   6:         _tprintf_s( _T( "%s\n" ), emp->GetFirstname() );
   7:         _tprintf_s( _T( "%s\n" ), emp->GetLastname() );
   8:     }
   9:  
  10:  
  11:     return 0;
  12: }

Da die Instanz nicht gelöscht wird, wird der Destruktor auch nicht aufgerufen und der allokierte Speicher nicht freigegeben.

Mit dem nächsten Update für Visual C++ 2008, Anfang des Jahres 2008, kommt eine erste Implementierung der nächsten C++ Standard Libraries, nämlich die Unterstützung des TR1 (Technical Report 1) Umfangs. Darin enthalten ist auch die shared_ptr<T> Klasse.

Das obige Beispiel sieht nun mit der shared_ptr<T> Klasse folgendermaßen aus:

   1: #include "stdafx.h"
   2: #include "Employee.h"
   3:  
   4: #include "memory"
   5: using namespace std::tr1;
   6:  
   7: int _tmain(int argc, _TCHAR* argv[])
   8: {
   9:     {
  10:         shared_ptr< Employee > emp( new Employee() );
  11:  
  12:         _tprintf_s( _T( "%s\n" ), emp->GetFirstname() );
  13:         _tprintf_s( _T( "%s\n" ), emp->GetLastname() );
  14:     }
  15:  
  16:     return 0;
  17: }

In Zeile 4 und 5 wird die Klasse referenziert und steht entsprechend in Zeile 10 zur Verfügung. Läuft nun die Instanz Out-of-Scope wird automatisch der Destruktor aufgerufen, hier ein Auszug aus der shared_ptr<T> Implementierung:

   1: void _Decref()
   2:     {    // decrement reference count
   3:     if (_Rep != 0)
   4:         delete _Rep->_Decref();
   5:     }

Es wird intern mit einem Reference-Counting gearbeitet, ähnlich dem Verfahren des COM Smart Pointer _com_ptr_t.

Alles in allem eine schöne Erweiterung, die man mit Sicherheit auch schon selbst in seine eigenen Bibliotheken eingearbeitet hatte. Nun kommt dies endlich in den nächsten C++ Standard und die Zukunft scheint ein Memory-Leak Problem weniger zu haben.