Beliebige RAII-Vorlage in Boost oder C++ 0x

Question

Gibt es eine verfügbare Vorlage in Boost für RAII. Es gibt Klassen wie scoped_ptr, shared_ptr, die grundsätzlich auf Zeiger arbeiten. Können diese Klassen für andere Ressourcen als Zeiger verwendet werden? Gibt es eine Vorlage, die mit allgemeinen Ressourcen arbeitet?

Nehmen Sie zum Beispiel eine Ressource, die am Anfang eines Bereichs erworben wird und am Ende des Bereichs irgendwie freigegeben werden muss. Beide erwerben und veröffentlichen einige Schritte. Wir könnten eine Vorlage schreiben, die zwei (oder vielleicht ein Objekt) Funktoren benötigt, die diese Aufgabe übernehmen. Ich habe nicht gedacht, es durch, wie dies erreicht werden kann, ich habe mich nur gefragt gibt es irgendwelche bestehenden Methoden es mit Unterstützung für Lambda-Funktionen

Answer 1

shared_ptr bietet die Möglichkeit, eine custom deleter anzugeben. Wenn der Zeiger zerstört werden muss, wird der Deleter aufgerufen und kann alle erforderlichen Bereinigungsaktionen ausführen. Auf diese Weise können mit dieser Smart-Pointer-Klasse komplexere Ressourcen als einfache Pointer verwaltet werden.

Answer 2

Der allgemeinste Ansatz

Edit: Wie wäre es ein in C++ 0x zu tun ist, die ScopeGuard man (Grundidee in this ddj article, implementiert z. B. mit Komfort-Makros in Boost.ScopeExit), und können Sie Funktionen ausführen oder Ressourcen beim Geltungsbereich Exit zu bereinigen.

Aber um ehrlich zu sein, sehe ich nicht, warum du das willst. Während ich verstehe, dass es ein bisschen nervig ist, jedes Mal eine Klasse für ein One-Step-Aquire- und One-Step-Release-Pattern zu schreiben, sprichst du von Multi-Step-Aquire und -Release.
Wenn es mehrere Schritte dauert, gehört es meiner Meinung nach in eine entsprechend benannte Dienstprogrammklasse, so dass die Details verborgen sind und der Code vorhanden ist (wodurch die Fehlerwahrscheinlichkeit verringert wird).
Wenn Sie es gegen die Gewinne abwägen, sind diese wenigen zusätzlichen Zeilen nicht wirklich etwas, worüber man sich Sorgen machen muss.

Answer 3

Ich muss zugeben, ich sehe nicht wirklich den Punkt. Einen RAII-Wrapper von Grund auf zu schreiben, ist bereits lächerlich einfach. Es gibt einfach nicht viel Arbeit mit einer Art von vordefinierten Wrapper gespeichert werden:

struct scoped_foo : private boost::noncopyable { 
    scoped_foo() : f(...) {} 
    ~scoped_foo() {...} 

    foo& get_foo() { return f; } 

private: 
    foo f; 
}; 

Nun werden die ... ‚s sind im Wesentlichen die Bits, die manuell werden müssten ausgefüllt, wenn Sie irgendeine Art von allgemeinen RAII verwendet Vorlage: Erstellung und Vernichtung unserer Ressource foo. Und ohne sie ist wirklich nicht viel übrig. Ein paar Zeilen Code, aber es ist so klein, dass es sich einfach nicht lohnt, es in eine wiederverwendbare Vorlage zu extrahieren, zumindest im Moment nicht. Mit dem Hinzufügen von Lambdas in C++ 0x könnten wir die Funktoren für Erzeugung und Zerstörung so prägnant schreiben, dass es sich lohnt, diese zu schreiben und sie in eine wiederverwendbare Vorlage zu stecken. Aber bis dahin scheint es mehr Mühe als wert zu sein. Wenn Sie zwei Funktoren definieren würden, die in eine RAII-Vorlage eingefügt werden sollen, hätten Sie bereits den Großteil dieses Standardcodes zweimal geschrieben.

Answer 4

Ich dachte an etwas ähnliches:

template <typename T> 
class RAII { 
    private: 
     T (*constructor)(); 
     void (*destructor)(T); 
    public: 
     T value; 
     RAII(T (*constructor)(), void (*destructor)(T)) : 
        constructor(constructor), 
        destructor(destructor) { 
      value = constructor(); 
     } 
     ~RAII() { 
      destructor(value); 
     } 
}; 

und wie diese verwendet werden (OpenGL GLUquadric als Beispiel):

RAII<GLUquadric*> quad = RAII<GLUquadric*>(gluNewQuadric, gluDeleteQuadric); 
gluSphere(quad.value, 3, 20, 20) 

Answer 5

Ein allgemeineres und effizienter (kein Anruf durch Funktionszeiger) Version ist wie folgt:

#include <boost/type_traits.hpp> 

template<typename FuncType, FuncType * Func> 
class RAIIFunc 
{ 
public: 
    typedef typename boost::function_traits<FuncType>::arg1_type arg_type; 
    RAIIFunc(arg_type p) : p_(p) {} 
    ~RAIIFunc() { Func(p_); } 
    arg_type & getValue() { return p_; } 
    arg_type const & getValue() const { return p_; } 
private: 
    arg_type p_; 
}; 

Beispiel Verwendung:

RAIIFunc<int (int), ::close> f = ::open("..."); 

Answer 6

Hier ist noch eine weitere C++ 11 RAH Helfer: https://github.com/ArtemGr/libglim/blob/master/raii.hpp

Es läuft eine C++ Funktors bei Zerstörung:

auto unmap = raiiFun ([&]() {munmap (fd, size);});