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 erste Implementierung 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.