HDF5 函数和智能析构函数 - std::unique_ptr()

Question

很多HDF5函数初始化如下

hid_t handler = DoSomething(someHandler);

并且必须手动释放由此类操作保留的内存，使用类似：

freeme(handler);

因此，使用malloc 和/或new 运算符会带来同样的噩梦/问题。

我想创建类似unique_ptr 的东西来处理这个问题。 问题是，每个不同的函数都有不同的释放函数。

例如：

hid_t attribType = H5Aget_type(attribHandler);

必须被释放

H5Tclose(attribType);

但是这个函数

attribHandler = H5Aopen(obj_id,"name",H5P_DEFAULT);

必须被释放

H5Aclose(attribHandler);

所以我需要编写一个可以将hid_t作为模板参数的类（这很容易），也可以将释放函数作为某种参数，并在销毁时调用它。

实现这一目标的最佳方法是什么？

---

更新

有人建议我将std::unique_ptr 与自定义删除器一起使用，但这不起作用，因为std::unique_ptr 需要一个指针。

std::unique_ptr<hid_t,std::function<herr_t(hid_t)>> attribType(H5Aget_type(attribHandler), [](hid_t f) { return H5Tclose(f); });

由于第二个参数 lambda 函数，这会产生编译错误。错误说（g++ 4.9）：

error: invalid conversion from ‘hid_t {aka int}’ to ‘std::unique_ptr<int, std::function<int(int)> >::pointer {aka int*}’ [-fpermissive]
         std::unique_ptr<hid_t,std::function<herr_t(hid_t)>> attribType(H5Aget_type(attribHandler), [](hid_t f) { return H5Tclose(f); });
                                                                                                 ^

发生错误是因为std::unique_ptr 期望持有指向hid_t 的指针，而不是hid_t 对象。

有没有办法解决这个问题？我想我现在可以编写自己的类来执行此操作（我可以使用 std::function 来回答我的第一个问题），但如果我可以使用 std::unique_ptr 那就太好了。

Answer 1

你可以使用类似的东西：

template <typename Factory, Factory factory,
          typename Deleter, Deleter deleter>
class SmartHandleH5;

template <typename Ret, typename ... Ts, Ret (*factory)(Ts...), 
          void (*deleter)(Ret)>
class SmartHandleH5<Ret (*)(Ts...), factory, void (*)(Ret), deleter>
{
public:
    template <typename ... Us>
    SmartHandle(Us&&... args) : handler(factory(std::forward<Us>(args)...)) {}

    // Not copyable
    SmartHandle(const SmartHandle&) = delete;
    SmartHandle& operator =(const SmartHandle&) = delete;

    // Not movable
    SmartHandle(SmartHandle&&) = delete;
    SmartHandle& operator =(SmartHandle&&) = delete;

    // To avoid strange case with our template constructor
    SmartHandle(SmartHandle&) = delete;
    SmartHandle(const SmartHandle&&) = delete;

    ~SmartHandle() { deleter(handler); }

    const T& get() const { return handler; }
    T& get() { return handler; }

private:
    Ret handler;
};

然后使用一次映射工厂/析构函数：

using SmartHandlerGetType = SmartHandlerH5<decltype(&H5Aget_type), H5Aget_type,
                                           delctype(H5Tclose), H5Tclose>;

using SmartHandlerOpen = SmartHandlerH5<decltype(&H5Aopen), H5Aopen, 
                                        delctype(H5Aclose), H5Aclose>;

并使用它：

SmartHandlerGetType attribType(attribHandler);
SmartHandlerOpen attribHandler(obj_id, "name", H5P_DEFAULT);

此外，您可能需要添加一个额外的图层以完全隐藏hid_t

template <typename SmartHandle>
class HidHandle : private SmartHandle
{
public:
    using SmartHandle::SmartHandle;

    void foo() { someFunctionUsingHid(get()); }
};

和

using HidHandleGetType = HidHandle<SmartHandlerGetType>;
using HidHandleOpen = HidHandle<SmartHandlerOpen>;

Answer 2

我创建了自己的处理程序类...结果并不难：

template <typename T, typename Deleter>
class SmartHandle
{
public:
    typedef T value_type;
    typedef Deleter deleter_function;
private:
    T _value;
    Deleter _deleter;
public:
    SmartHandle(T value, Deleter deleter);
    ~SmartHandle();

    T get();
};

template <typename T, typename Deleter>
SmartHandle<T,Deleter>::SmartHandle(T value, Deleter deleter)
{
    this->_value   = value;
    this->_deleter = deleter;
}

template <typename T, typename Deleter>
T SmartHandle<T,Deleter>::get()
{
    return _value;
}

template <typename T, typename Deleter>
SmartHandle<T,Deleter>::~SmartHandle()
{
    _deleter(_value);
}

使用它：

SmartHandle<hid_t,std::function<herr_t(hid_t)>> attribType(H5Aget_type(attribHandler.get()), [](hid_t f) { return H5Tclose(f); });

这里attribHandler 也使用SmartHandle，这就是为什么那里有.get()。

Answer 3

也许是这样的：

struct MyDeleter {
  typedef hid_t pointer;
  typedef void (*FreeFunc)(hid_t);
  FreeFunc free_func_;

  MyDeleter(FreeFunc free_func) : free_func_(free_func) {}
  void operator()(hid_t f) const { free_func_(f); }
};

std::unique_ptr<hid_t, MyDeleter> p(
    H5Aget_type(attribHandler),
    MyDeleter(H5Tclose));