Question

在我的C ++代码中，有时我需要从某些库调用C函数。有时这些是配对功能，例如锁定功能，然后是解锁功能。我想确保我不会忘记调用解锁功能。所以我正在尝试编写一个模板类来处理它，但我无法做到正确。

template <class T>
class CInReleaser
{
public:
    CInReleaser(T func) : _func(func) {}
    ~CInReleaser() { _func();}
    T _func;
};

void somefunc()
{
    DATA something;
    // call locking function
    lock_something(something);
    CInReleaser<XXX> release(boost::bind(unlock_something,something));
    .
    .
}

当somefunc（）函数结束时，应该调用函数unlock_something（）。但是我无法预测XXX类型。我怎样才能编译它？

Answer 1

创建一个包装器工厂函数来利用函数模板参数推导：

template<typename T>
CInReleaser<T> makeReleaser(T func) {
  return CInReleaser<T>(func);
}

然后在代码中：

auto release = makeReleaser(boost::bind(unlock_something,something));

Answer 2

创建一个锁定构造函数并在析构函数中解锁的类。

template <class Lock, class Unlock>
struct CInReleaser
{
   CInReleaser(Lock lock, Unlock unlock) : _lock(lock), _unlock(unlock)
   {
      _lock();
   }
   ~CInReleaser()
   {
      _unlock();
   }
};

创建一个函数来帮助构造类的语法。

template <class Lock, class Unlock>
CInReleaser<Lock, Unlock> makeCInReleaser(Lock lock, Unlock unlock)
{
   return CInReleaser<Lock, Unlock>(lock, unlock);
}

使用示例。

void somefunc()
{
   auto releaser = makeCInReleaser(boost::bind(lock_something, something),
                                   boost::bind(unlock_something, something));
}

Answer 3

如果你有c ++ 11支持，我建议你使用像这样的小帮手

class Guard
{
public:
    Guard(std::function<void()> fn) : fn_(std::move(fn)) {}
    ~Guard() { if(fn_) fn_(); }
private:
    std::function<void()> fn_;
};

然后你可以使用一个小lambda来编写它

void somefunc()
{
    DATA something;
    // call locking function
    lock_something(something);
    Guard g([=](){ something->unlock_something(); });
    .
    .
}

如何选择函数指针类型？

3 个答案: