c++ - 在函数退出前调用函数

Question

我将从一个例子开始。假设我需要在互斥体中保护一个带有函数的代码。有两种实现方法。

#include <iostream>
#include <vector>
#include <pthread.h>



pthread_mutex_t myMutex = PTHREAD_MUTEX_INITIALIZER;
std::vector<float> myVec;

void threadfunc(int i, float value)
{
  pthread_mutex_lock(&myMutex);
  if(i <= 0 || i > myVec.size())
  {
    pthread_mutex_unlock(&myMutex);
    return;
  }

  if(value < 0)
  {
    pthread_mutex_unlock(&myMutex);
    return;
  }

  myVec[i] += value;
  pthread_mutex_unlock(&myMutex);
  return;
}

class AUTOMUTEX
{
  private:
    pthread_mutex_t *mMutex;
  public:
    AUTOMUTEX(pthread_mutex_t *mutex): mMutex(mutex)
  {
    pthread_mutex_lock(mMutex);
  }

    ~AUTOMUTEX()
    {
      pthread_mutex_unlock(mMutex);
    }
};


void threadfunc_autolock(int i, float value)
{
  AUTOMUTEX  autoMutex(&myMutex);
  if(i <= 0 || i > myVec.size())
  {
    return;
  }

  if(value < 0)
  {
    return;
  }

  myVec[i] += value;
  return;
}

int  main()
{
  threadfunc_autolock(5, 10);
  threadfunc(0, 7);
  return 1;
}

从示例中可以清楚地看出，threadfunc autolock 是更好的实现，因为调用 pthread_mutex_unlock 函数返回由对 AUTOMUTEX 的析构函数调用负责(C++ 11 线程支持此功能。因此，如果我们不需要自己实现 AUTOMUTEX正在使用 C++11 线程库)。 每次我们需要使用一些设置/重置函数对执行此操作时，有没有一种方法可以在不实现包装类的情况下实现这一点。 boost 或 C++ 11 是否有一些预定义的模板类，我们可以使用这些模板类为任何此类“设置/重置”功能实现 AUTOMUTEX 的行为。这对于具有多个返回点的函数非常有用。 换句话说，boost/C++ 是否提供了具有以下行为的类。

//sample code not compilable.
template <class T, class Y>
class myAuto
{
  myAuto()
{ 
   T();
}
  ~myAuto()
{
  Y();
};

Answer 1

你可以编写自己的 geneirc RAII 类，比如:

class Finally
{
public:
    explicit Finally(std::function<void()> f) : mF(f) {}
    ~Finally() noexcept() {
        try
        {
            mF();
        } catch (...) {
            // Handle error.
        } 
    }

    Finally(const Finally&) = delete;
    Finally(Finally&&) = delete;

    Finally& operator=(const Finally&) = delete;
    Finally& operator=(Finally&&) = delete;

private:
    std::function<void()> mF;
};

用法:

{
    pthread_mutex_lock(&myMutex);
    Finally finally([&](){ pthread_mutex_unlock(&myMutex); });

    //..
}

即使专用 RAII 对象在某些情况下可能更合适(如 Mutex)。