Kein RAII - Kein Spaß

Wer “Resource Acquisition Is Initialization” - kurz RAII - nicht kennt, hat nicht das Recht sich als C++ Entwickler zu bezeichnen.

Und selbstverständlich gehört auch die Umkehrung dazu: “Resource Release Is Destruction” - kurz RRID.

Doch die Primärimplementierung im GATE Projekt findet in C statt und hier fehlt dieses C++ Konzept wirklich sehr.

In C++ schreibt man sich einmal eine “Smart-Resource” Klasse …

class MyResource
{
private:
  resource_type	res;
  
public:
  MyResource()
  {
    this->res = create_my_resource();
    if(this->res == NULL)
    {
      throw std::runtime_error("Failed to create resouce");
    }
  }
  ~MyResource()
  {
    delete_my_resource(this->res);
  }
  
  resource_type get()
  {
    return this->res;
  }
};

… und diese bindet man dann im Programm ganz natürlich ein:

void do_something()
{
  MyResource res1;
  MyResource res2;
  MyResource res3;
  MyResource res4;
  
  ...
}

Der Programmablauf do_something() sieht damit in C++ sehr sauber aus und der Compiler garantiert die korrekte Freigabe aller Ressourcen.

Aber was tun wir jetzt in reinem C ?

Tja, hier wird oft alles in eine Funktion gepackt. Aber hier müssen wir uns um eine korrekte Ressourcenverwaltung selbst kümmern. Mein alter eingelernter Ansatz sieht dann so aus:

int do_something()
{
  int succeeded = 0;
  resource_type res1 = NULL;
  resource_type res2 = NULL;
  resource_type res3 = NULL;
  resource_type res4 = NULL;
  
  do
  {
    res1 = create_my_resource();
    if(res1 == NULL) break;
    res2 = create_my_resource();
    if(res2 == NULL) break;
    res3 = create_my_resource();
    if(res3 == NULL) break;
    res4 = create_my_resource();
    if(res4 == NULL) break;
	
    ...  
	
    succeeded = 1;
  } while(0);
  
  if(res1 != NULL) delete_my_resource(res1);
  if(res2 != NULL) delete_my_resource(res2);
  if(res3 != NULL) delete_my_resource(res3);
  if(res4 != NULL) delete_my_resource(res4);
  
  return succeeded;
}

Und jetzt stellen wir uns das Beispiel mit 4 mal so vielen Ressourcen vor …

Dann wird unser do_something() schon ganz schön unübersichtlich. Auch die Frage, an welcher Stelle man eine Funktion “abbrechen” darf, ist in C++ dank Exceptions leichter und schöner beschreibbar, als in C. Und zusätzlich müssen wir uns den uninitialisierten Zustand auch noch irgendwie merken.

Fazit: Schätze deinen C++ Compiler!
Denn im Gegensatz zu uns Programmierern greift er das Thema Ressourcenverwaltung (meist) viel genauer und zuverlässiger auf.


Wenn sich eine triviale Erkenntnis mit Dummheit in der Interpretation paart, dann gibt es in der Regel Kollateralschäden in der Anwendung.
frei zitiert nach A. Van der Bellen
... also dann paaren wir mal eine komplexe Erkenntnis mit Klugheit in der Interpretation!