Was ist mit "Resource Acquisition is Initialization (RAII)" gemeint?

Question

Was ist mit "Resource Acquisition is Initialization (RAII)" gemeint?

Answer 1

Es ist ein wirklich schrecklicher Name für ein unglaublich leistungsfähiges Konzept und vielleicht eines der wichtigsten Dinge, die C++-Entwickler vermissen, wenn sie zu anderen Sprachen wechseln. Es hat eine kleine Bewegung gegeben, die versucht, dieses Konzept umzubenennen in Umfangsgebundenes Ressourcenmanagement Allerdings scheint es sich noch nicht durchgesetzt zu haben.

Wenn wir "Ressource" sagen, meinen wir nicht nur Speicher - es können auch Datei-Handles, Netzwerk-Sockets, Datenbank-Handles, GDI-Objekte usw. sein. Kurz gesagt, Dinge, die wir nur begrenzt zur Verfügung haben und deren Verwendung wir daher kontrollieren können müssen. Der "Scope-bound"-Aspekt bedeutet, dass die Lebensdauer des Objekts an den Scope einer Variablen gebunden ist, so dass der Destruktor die Ressource freigibt, wenn die Variable den Scope verlässt. Eine sehr nützliche Eigenschaft dieses Aspekts ist, dass er für eine größere Ausnahmesicherheit sorgt. Vergleichen Sie zum Beispiel dies:

RawResourceHandle* handle=createNewResource();
handle->performInvalidOperation();  // Oops, throws exception
...
deleteResource(handle); // oh dear, never gets called so the resource leaks

Mit dem RAII kann man

class ManagedResourceHandle {
public:
   ManagedResourceHandle(RawResourceHandle* rawHandle_) : rawHandle(rawHandle_) {};
   ~ManagedResourceHandle() {delete rawHandle; }
   ... // omitted operator*, etc
private:
   RawResourceHandle* rawHandle;
};

ManagedResourceHandle handle(createNewResource());
handle->performInvalidOperation();

Im letzteren Fall werden die lokalen Variablen zerstört, wenn die Ausnahme ausgelöst und der Stapel abgewickelt wird, wodurch sichergestellt wird, dass unsere Ressource aufgeräumt wird und nicht ausläuft.

Answer 2

Dies ist eine Programmiersprache, die kurz gesagt bedeutet, dass Sie

• eine Ressource in einer Klasse kapseln (deren Konstruktor normalerweise - aber nicht notwendigerweise** - die Ressource erwirbt und deren Destruktor sie immer freigibt)
• die Ressource über eine lokale Instanz der Klasse verwenden*
• die Ressource wird automatisch freigegeben, wenn das Objekt den Anwendungsbereich verlässt

Dies garantiert, dass die Ressource, egal was passiert, während sie in Gebrauch ist, irgendwann freigegeben wird (sei es durch normale Rückkehr, Zerstörung des sie enthaltenden Objekts oder durch eine ausgelöste Ausnahme).

Dies ist eine weit verbreitete gute Praxis in C++, da es nicht nur ein sicherer Weg ist, mit Ressourcen umzugehen, sondern auch Ihren Code viel sauberer macht, da Sie keinen Fehlerbehandlungscode mit der Hauptfunktionalität mischen müssen.

* Aktualisierung: "local" kann eine lokale Variable oder eine nichtstatische Mitgliedsvariable einer Klasse bedeuten. Im letzteren Fall wird die Mitgliedsvariable mit ihrem Eigentümerobjekt initialisiert und zerstört.

** Update2: Wie @sbi feststellte, kann die Ressource - obwohl sie oft innerhalb des Konstruktors zugewiesen wird - auch außerhalb zugewiesen und als Parameter übergeben werden.

Answer 3

"RAII" steht für "Resource Acquisition is Initialization" (Ressourcenerwerb ist Initialisierung) und ist eigentlich eine falsche Bezeichnung, da es sich nicht um Ressourcen Erwerb (und die Initialisierung eines Objekts), mit der es sich befasst, sondern Freisetzung von die Ressource (mit Hilfe von Zerstörung eines Objekts).
Aber RAII ist der Name, den wir bekommen haben, und er bleibt haften.

Im Kern besteht das Idiom aus der Kapselung von Ressourcen (Speicherabschnitte, geöffnete Dateien, nicht gesperrte Mutexe, usw.) in lokale, automatische Objekte und dass der Destruktor dieses Objekts die Ressource freigibt, wenn das Objekt am Ende des Bereichs, zu dem es gehört, zerstört wird:

{
  raii obj(acquire_resource());
  // ...
} // obj's dtor will call release_resource()

Natürlich sind Objekte nicht immer lokale, automatische Objekte. Sie können auch Mitglieder einer Klasse sein:

class something {
private:
  raii obj_;  // will live and die with instances of the class
  // ... 
};

Wenn solche Objekte Speicher verwalten, werden sie oft als "Smart Pointer" bezeichnet.

Hiervon gibt es viele Varianten. In den ersten Codeschnipseln stellt sich zum Beispiel die Frage, was passieren würde, wenn jemand Folgendes kopieren wollte obj . Der einfachste Ausweg wäre, das Kopieren einfach zu verbieten. std::unique_ptr<> ein intelligenter Zeiger, der Teil der Standardbibliothek sein soll und im nächsten C++-Standard enthalten sein wird, tut dies.
Noch so ein kluger Hinweis, std::shared_ptr verfügt über "Shared Ownership" für die Ressource (ein dynamisch zugewiesenes Objekt), die es enthält. Das heißt, es kann frei kopiert werden und alle Kopien beziehen sich auf dasselbe Objekt. Der intelligente Zeiger verfolgt, wie viele Kopien auf dasselbe Objekt verweisen, und löscht es, wenn die letzte Kopie zerstört wird.
Eine dritte Variante wird vorgestellt von std::auto_ptr die eine Art von Bewegungs-Semantik implementiert: Ein Objekt gehört nur einem Zeiger, und der Versuch, ein Objekt zu kopieren, führt (durch Syntax-Hackerei) dazu, dass das Eigentum an dem Objekt auf das Ziel des Kopiervorgangs übertragen wird.

Answer 4

Die Lebensdauer eines Objekts wird durch seinen Geltungsbereich bestimmt. Manchmal ist es jedoch notwendig oder nützlich, ein Objekt zu erstellen, das unabhängig von dem Bereich lebt, in dem es erstellt wurde. In C++ ist der Operator new wird verwendet, um ein solches Objekt zu erstellen. Und um das Objekt zu zerstören, wird der Operator delete verwendet werden können. Vom Operator erstellte Objekte new werden dynamisch zugewiesen, d. h. im dynamischen Speicher (auch als Haufen ou freies Lager ). So kann ein Objekt, das von new existiert so lange, bis sie explizit mit delete .

Einige Fehler, die bei der Verwendung von new y delete sind:

• Durchgesickertes Objekt (oder Speicher): mit new ein Objekt zuzuweisen und zu vergessen delete das Objekt.
• Vorzeitig löschen (oder hängender Verweis ): hält einen weiteren Zeiger auf ein Objekt, delete das Objekt, und verwenden Sie dann den anderen Zeiger.
• Doppeltes Löschen : Versuch einer delete ein Objekt zweimal.

Im Allgemeinen werden skalierte Variablen bevorzugt. RAII kann jedoch als Alternative zu new y delete um ein Objekt unabhängig von seinem Geltungsbereich leben zu lassen. Eine solche Technik besteht darin, den Zeiger auf das Objekt, das auf dem Heap zugewiesen wurde, in einen handle/manager object . Letzteres hat einen Destruktor, der sich um die Zerstörung des Objekts kümmert. Damit wird sichergestellt, dass das Objekt jeder Funktion zur Verfügung steht, die darauf zugreifen möchte, und dass das Objekt zerstört wird, wenn die Lebensdauer der Griffobjekt endet, ohne dass eine explizite Bereinigung erforderlich ist.

Beispiele aus der C++-Standardbibliothek, die RAII verwenden, sind std::string y std::vector .

Betrachten Sie dieses Stück Code:

void fn(const std::string& str)
{
    std::vector<char> vec;
    for (auto c : str)
        vec.push_back(c);
    // do something
}

Wenn Sie einen Vektor erstellen und ihm Elemente hinzufügen, müssen Sie sich nicht um die Zuweisung und Freigabe solcher Elemente kümmern. Der Vektor verwendet new um Platz für seine Elemente auf dem Heap zuzuweisen, und delete um diesen Platz freizugeben. Als Nutzer von vector sind Ihnen die Implementierungsdetails egal und Sie vertrauen darauf, dass vector nicht ausläuft. In diesem Fall ist der Vektor der Griffobjekt seiner Elemente.

Weitere Beispiele aus der Standardbibliothek, die RAII verwenden, sind std::shared_ptr , std::unique_ptr であり、また std::lock_guard .

Ein anderer Name für diese Technik ist SBRM , kurz für Umfangsgebundenes Ressourcenmanagement .

Answer 5

Das Buch C++-Programmierung mit aufgedeckten Entwurfsmustern beschreibt RAII als:

1. Beschaffung aller Ressourcen
2. Einsatz von Ressourcen
3. Freisetzung von Ressourcen

Wo

• Ressourcen sind als Klassen implementiert, und alle Zeiger haben Klassenumhüllungen um sich herum (was sie zu intelligenten Zeigern macht).

• Ressourcen werden durch Aufrufen ihrer Konstruktoren erworben und implizit (in umgekehrter Reihenfolge des Erwerbs) durch Aufrufen ihrer Destruktoren freigegeben.