Qualsiasi modello RAII in boost o C++ 0x

Question

Esiste un modello disponibile in boost per RAII. Esistono classi come scoped_ptr, shared_ptr che funzionano fondamentalmente sul puntatore. Queste classi possono essere utilizzate per qualsiasi altra risorsa oltre ai puntatori. Esiste un modello che funzioni con risorse generali.

Prendiamo ad esempio una risorsa che viene acquisita all'inizio di un ambito e che deve essere in qualche modo rilasciata alla fine dello scope. Entrambi acquisiscono e rilasciano alcuni passi. Potremmo scrivere un modello che richiede due (o forse un oggetto) funtori che fanno questo compito. I havent pensato che attraverso il modo questo può essere realizzato, mi stavo chiedendo ci sono dei metodi esistenti per farlo

Edit: Come circa uno in C++ 0x con il supporto per le funzioni lambda

Answer 1

shared_ptr offre la possibilità di specificare un custom deleter. Quando il puntatore deve essere distrutto, il deleter verrà richiamato e potrà eseguire tutte le azioni di pulizia necessarie. In questo modo è possibile gestire risorse più complicate rispetto a semplici puntatori con questa classe di puntatore intelligente.

Answer 2

L'approccio più generica è il ScopeGuard (idea di base in this ddj article, implementata ad esempio con i macro di convenienza in Boost.ScopeExit) e consente di eseguire funzioni o ripulire le risorse all'uscita dell'ambito.

Ma a dire il vero, non vedo perché lo vorrai. Mentre capisco che è un po 'fastidioso scrivere una classe ogni volta per un modello in un passo-aquire e in un passo-passo, stai parlando di aquila-scatto a più gradini.
Se preso più passaggi, a mio parere, appartiene a una classe di utilità denominata appropriatamente, in modo che i dettagli siano nascosti e il codice in atto (riducendo così la probabilità di errore).
Se si appesantisce rispetto ai guadagni, quelle poche righe aggiuntive non sono davvero qualcosa di cui preoccuparsi.

Answer 3

Devo ammettere che non capisco il punto. Scrivere un wrapper RAII da zero è già ridicolmente semplice. C'è solo non molto lavoro per essere salvati utilizzando una sorta di involucro predefinita:

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

    foo& get_foo() { return f; } 

private: 
    foo f; 
}; 

Ora, le ... 's sono essenzialmente i bit che avrebbe dovuto essere compilato manualmente se è stato utilizzato un qualche tipo di RAII generale modello: creazione e distruzione della nostra risorsa foo. E senza di loro non è rimasto molto. Alcune righe di codice boilerplate, ma è così piccolo che non sembra valsa la pena estrarlo in un template riutilizzabile, almeno non al momento. Con l'aggiunta di lambda in C++ 0x, potremmo scrivere i funtori per la creazione e la distruzione in modo così conciso che è possibile che valga la pena di scriverli e inserirli in un modello riutilizzabile. Ma fino ad allora, sembra che sarebbe più un problema che altro. Se dovessi definire due funtori da inserire in un modello RAII, avresti già scritto la maggior parte di questo codice boiler due volte.

Answer 4

stavo pensando a qualcosa di simile:

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); 
     } 
}; 

e da utilizzare in questo modo (usando GLUquadric di OpenGL come esempio):

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

Answer 5

un più generico e più efficiente (nessuna chiamata tramite puntatore versione di funzione) è la seguente: uso

#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_; 
}; 

Esempio:

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

Answer 6

Ecco ancora un altro C++ 11 RAII aiutante: https://github.com/ArtemGr/libglim/blob/master/raii.hpp

Si corre un funtore C++ alla distruzione:

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