用于函数对和模板专门化的RAII包装器

Question

我已经为C函数对编写了一个RAII包装器，用于初始化和释放资源，它在大多数情况下都很好用。

#include <GL/glfw.h>
#include <string>
#include <functional>
#include <stdexcept>
template <typename UninitFuncType,
          typename SuccessValueType,
          SuccessValueType successValue>
class RAIIWrapper
{
public:
    template <typename InitFuncType, typename... Args>
    RAIIWrapper(InitFuncType initializer,
                UninitFuncType uninitializer,
                const std::string &errorString,
                const Args&... args) : 
        uninit_func(uninitializer)
    {
        if (successValue != initializer(args...))
            throw std::runtime_error(errorString);
        initialized = true;
    }
    bool isInitialized() const
    {
        return initalized;
    }
    ~RAIIWrapper()
    {
        if (initalized)
            uninit_func();
    }
    // non-copyable
    RAIIWrapper(const RAIIWrapper &) = delete;
    RAIIWrapper& operator=(const RAIIWrapper &) = delete;
private:
    bool initalized = false;
    std::function<UninitFuncType> uninit_func;
};
using GLFWSystem = RAIIWrapper<decltype(glfwTerminate), decltype(GL_TRUE), GL_TRUE>;
using GLFWWindow = RAIIWrapper<decltype(glfwCloseWindow), decltype(GL_TRUE), GL_TRUE>;
int main()
{
    GLFWSystem glfw(glfwInit,
                    glfwTerminate,
                    "Failed to initialize GLFW");
}

然而，说当一个函数返回void像Enter/LeaveCriticalSection我不确定如何去做，并在这个类。我应该专门为SuccessValueType = void案例开设课程吗?或者使用默认模板参数应该做什么?

Answer 1

我想指出的是，

1. 在包装器类中不需要关于初始化函数的信息。你只需要知道反初始化函数

2. 你可以创建函数帮助器来实例化你的包装器

我想出了以下解决方案(我喜欢@ipc异常处理的想法)

template <typename UninitF>
struct RAII_wrapper_type
{
    RAII_wrapper_type(UninitF f)
    :_f(f), _empty(false)
    {}
    RAII_wrapper_type(RAII_wrapper_type&& r)
    :_f(r._f), _empty(false)
    {
      r._empty = true;
    }
    RAII_wrapper_type(const RAII_wrapper_type&) = delete;
    void operator=(const RAII_wrapper_type&) = delete;
    ~RAII_wrapper_type()
    {
      if (!_empty) {
        _f();
      }
    }
  private:
    UninitF _f;
    bool _empty; // _empty gets true when _f is `moved out` from the object.
};
template <typename InitF, typename UninitF, typename RType, typename... Args>
RAII_wrapper_type<UninitF> capture(InitF init_f, UninitF uninit_f, RType succ, 
                                   const char* error, Args... args)
{
  if(init_f(args...) != succ) {
    throw std::runtime_error(error);
  }
  return RAII_wrapper_type<UninitF>(uninit_f);
}
template<typename InitF, typename UninitF, typename... Args>
RAII_wrapper_type<UninitF> capture(InitF init_f, UninitF uninit_f, Args... args)
{
  init_f(args...);
  return RAII_wrapper_type<UninitF>(uninit_f);
}

的例子:

void t_void_init(int){}
int t_int_init(){ return 1; }
void t_uninit(){}
int main()
{
  auto t1 = capture(t_void_init, t_uninit, 7);
  auto t2 = capture(t_int_init, t_uninit, 0, "some error");
}

编辑

RAII_wrapper_type应该有移动语义，我们应该小心地实现它的移动构造函数，以防止uninit_f调用多次。

Answer 2

我会将返回检查和raii包装的逻辑分开

template <typename UninitFuncType>
class RAIIWrapper
{
public:
  template <typename InitFuncType, typename... Args>
  RAIIWrapper(InitFuncType fpInitFunc,
              UninitFuncType fpUninitFunc,
              Args&&... args)
    : fpUninit(std::move(fpUninitFunc))
  {
    static_assert(std::is_void<decltype(fpInitFunc(args...))>::value, "ignored return value");
    fpInitFunc(std::forward<Args>(args)...);
  }
  bool isInitialized() const { return true; } // false is impossible in your implementation
  ~RAIIWrapper() { fpUninit(); } // won't be called if constructor throws
private:
  UninitFuncType fpUninit; // avoid overhead of std::function not needed
};
template <typename InitFuncType, typename UninitFuncType, typename... Args>
RAIIWrapper<UninitFuncType>
raiiWrapper(InitFuncType fpInitFunc,
            UninitFuncType fpUninitFunc,
            Args&&... args)
{
  return RAIIWrapper<typename std::decay<UninitFuncType>::type>
    (std::move(fpInitFunc), std::move(fpUninitFunc), std::forward<Args>(args)...);
}
template <typename InitFuncType, typename SuccessValueType>
struct ReturnChecker {
  InitFuncType func;
  SuccessValueType success;
  const char *errorString;
  ReturnChecker(InitFuncType func,
                SuccessValueType success,
                const char *errorString)
    : func(std::move(func)), success(std::move(success)), errorString(errorString) {}
  template <typename... Args>
  void operator()(Args&&... args)
  {
    if (func(std::forward<Args>(args)...) != success)
      throw std::runtime_error(errorString);
  }
};
template <typename InitFuncType, typename SuccessValueType,
          typename Ret = ReturnChecker<InitFuncType, SuccessValueType> >
Ret checkReturn(InitFuncType func, SuccessValueType success, const char *errorString)
{
  return Ret{func, success, errorString};
}

我还添加了允许类型演绎的函数。下面是它的用法:

auto _ = raiiWrapper(checkReturn(glfwInit, GL_TRUE, "Failed to initialize GLFW"),
                     glfwTerminate);

由于具有非空返回值的函数对象会导致static_assert失败，因此以下操作是不可能的:

raiiWrapper(glfwInit, glfwTerminate); // fails compiling

如果你真的想忽略它，你可以添加一个ignoreReturn函数对象。还请注意，返回代码检查可以像您想要的那样复杂(例如成功必须是偶数)，因为您可以编写自己的返回代码检查器。