Любой шаблон RAII в boost или C++0x

shared_ptr предоставляет возможность указать пользовательское средство удаления . Когда указатель необходимо уничтожить, вызывается средство удаления, которое может выполнять любые необходимые действия по очистке. Таким образом, с помощью этого класса интеллектуальных указателей можно управлять более сложными ресурсами, чем простые указатели.

Наиболее общий подход — ScopeGuard (основная идея в эта статья ddj, реализованная, например, с помощью удобных макросов в Boost.ScopeExit) и позволяет выполнять функции или очищать ресурсы при выходе из области видимости.

Но, честно говоря, я не понимаю, зачем тебе это. Хотя я понимаю, что немного раздражает каждый раз писать класс для шаблона одноэтапного получения и одноэтапного выпуска, вы говорите о многоэтапном приобретении и выпуске.
Если было выполнено несколько шагов , он, на мой взгляд, принадлежит к служебному классу с соответствующим названием, так что детали скрыты, а код на месте (таким образом снижается вероятность ошибки). есть о чем беспокоиться.

Более общая и более эффективная (без вызова через указатель функции) версия выглядит следующим образом:

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

Пример использования:

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

Должен признаться, я действительно не вижу смысла. Написание оболочки RAII с нуля уже смехотворно просто. Просто не так много работы, которую можно сэкономить, используя какую-то предопределенную оболочку:

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

  foo& get_foo() { return f; }

private:
  foo f;
};

Теперь ... — это, по сути, биты, которые нужно было бы заполнить вручную, если бы вы использовали какой-то общий шаблон RAII: создание и уничтожение нашего ресурса foo. А без них действительно мало что остается. Несколько строк шаблонного кода, но их так мало, что кажется нецелесообразным извлекать их в повторно используемый шаблон, по крайней мере, на данный момент. С добавлением лямбда-выражений в C++0x мы могли написать функторы для создания и уничтожения настолько лаконично, что может быть стоит написать их и подключить к повторно используемому шаблону. Но до тех пор кажется, что это будет больше проблем, чем пользы. Если бы вам нужно было определить два функтора для включения в шаблон RAII, вы бы уже написали большую часть этого стандартного кода дважды.

Я думал о чем-то подобном:

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

и для использования следующим образом (на примере OpenGL GLUquadric):

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

Вот еще один помощник C++11 RAII: https://github.com/ArtemGr/libglim/blob/master/raii.hpp

Он запускает функтор C++ при уничтожении:

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