如何选择函数指针类型？ 在我的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)); . . } 模板 类释放器 { 公众： CInReleaser（T func）：_func（func）{} ~CInReleaser（）{u func（）；} T_func； }; void somefunc（） { 数据； //呼叫锁定功能 锁定某物（某物）； CInReleaser释放（boost:：bind（解锁某物，某物））； . . }

somefunc（）函数结束时应调用unlock_something（）函数。然而，我无法预测XXX的类型。如何编译此函数？

创建包装器工厂函数以利用函数模板参数推断：

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

---

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

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

---

如果您有c++11支持，我建议您使用这样的小助手

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

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

---

最好在构造函数中锁定，在析构函数中解锁。然后实例化一个保护对象。锁定不会总是在同一个范围内发生。但是在构造函数中锁定并不能解决我的问题。到目前为止，您尝试了什么而不是XXX？你收到了什么错误信息？与其重新发明轮子，不如看看安东尼·威廉姆斯的书，我认为这本书会很有帮助。具体来说，第459页讨论了C++11中的

std:：lock\u guard

类模板。第64页演示如何使用

boost:：shared_mutex

而不是

std:：mutex

。宾果！就是这样。我想要一种简单的方法来预测类型，因为每次使用不同的参数时，函数都可能不同。非常感谢。锁定和解锁功能可能不在同一范围内。所以这不行。此外，我需要将参数传递给函数，因此需要bind。看看公认的答案，它同时满足了两个要求。@SharathKShetty有很多优点。我更新了我的答案来解决这些问题。lambda特性的有趣用法。我不确定我是否完全理解，但我会试试看。了解可能很有用。Guard类实际做的是接受任何没有参数的函数并返回void。您也可以传递一个全局函数，但在这个示例中，我只传递了一个正是该类型的lambda（没有参数，返回void）。当作用域退出时，要做的就是在lambda中声明（这里我只是在something对象上调用了unlock_something（），但您可以将所有内容都放在其中）。我对右值引用的std:：move（）不确定。虽然我已经读过了，但直到现在我才真正使用它。移动部分对这里的想法来说并不是那么重要。您可以通过引用传递fn。我试图提出一个更灵活的方法，这就是为什么我在这里采取了行动。当您指定一个lambda或一个具有大量状态（成员变量）的用户定义函子时，移动可能会带来好处，因为所有成员都可能被移动。实际上，我经常使用移动语义，我非常喜欢它，我认为它确实值得一看，但对于您的特定示例，它只是没有必要。

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

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

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