每天进步一点点——C++11中使用lambda表达式实现一个简单的ScopeGuard
转载请说明出处：http://blog.csdn.net/cywosp/article/details/29585227
1. RAII
在进入本文主要内容之前先了解一下C++中常用的RAII（Resource acquisition is initialization）技术，即资源获取即初始化。其利用C++对象生命周期的概念来控制 程序的资源，例如内存、文件句柄、网络连接以及审计追踪(audit trail)等。RAII的基本技术原理很简单，若希望保持对某个重要资源的跟踪，那么创建一个对象，并将资源的生命周期和对象的生命周期相关联，如此一来，就可以利用C++复杂老练的对象管理设施来管理资源。最简单的RAII形式是创建这样一个对象：其构造函数获取一份资源，而析构函数则释放这份资源。在最新的C++标准中有如下数据类型：std::lock_guard、std::unique_lock、std::shared_ptr、std::unique_ptr等等都是RAII技术的很好体现，同时我们也可以自己现实对相关资源的初始化以及释放，例如在多线程编程中我们往往会忘记释放锁而导致线程死锁：
class Mutex{public:Mutex () {pthread_mutex_init (&mu_, NULL);}~Mutex () {pthread_mutex_destroy (&mu_);}void lock () {pthread_mutex_lock (&mu_);}void unlock () {pthread_mutex_unlock (&mu_);}
private:pthread_mutex_t mu_;
// No copyingMutex (const Mutex&);void operator= (const Mutex&);};
Mutex lock;{std::lock_guardguard (lock); // lock is locked by guard ……}// lock is not locked by anyone
……
2. Lambda表达式
C++11中的Lambda表达式用于定义并创建匿名的函数对象，以简化编程工作。Lambda的语法形式如下：
[函数对象参数] (操作符重 载函数参数) mutable或exception声明;返回值类型 {函数体};
可以看到，Lambda主要分为五个部分：[函数对象参数]、(操作符重载函数参数)、mutable或exception声明、返回值类型、{函数体}。下面分别进行介绍。
一、[函数对象参数]，标识一个Lambda的开始，这部分必须存在，不能省略。函数对象参数是传递给编译器自动生成的函数对象类的构造函数的。函数对象参数只能使用那些到定 义Lambda为止时Lambda所在作用范围内可见的局部变量（包括Lambda所在类的this）。函数对象参数有以下形式：
1、[] 没有使用任何函数对象参数。
2、[=] 函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是值传递方式（相当于编译器自动为我们按值传递了所有局部变量）。
3、[&] 函数体内可以使用Lambda所在作用范围内所有可见的局部变量（包括Lambda所在类的this），并且是引用传递方式（相当于编译器自动为我们按引用传递了所有局部变量）。
4、[this] 函数体内可以使用Lambda所在类中的成员变量。
5、[a] 将a按值进行传递。按值进行传递时，函数体内不能修改传递进来的a的拷贝，因为默认情况下函数是const的。要修改传递进来的a的拷贝，可以添加mutable修饰符。
6、[&a] 将a按引用进行传递。
7、[a, &b] 将a按值进行传递，b按引用进行传递。
8、[=，&a, &b] 除a和b按引用进行传递外，其他参数都按值进行传递。
9、[&, a, b] 除a和b按值进行传递外，其他参数都按引用进行传递。
二、(操作符重载函数参数)，标识重载的()操作符的参数，没有参数时，这部分可以省略。参数可以通过按值（如：(a,b)）和按引用（如：(&a,&b)）两种方式进行传递。
三、mutable或exception声明，这部分可以省略。按值传递函数对象参数时，加上mutable修饰符后，可以修改按值传递进来的拷贝（注意是能修改拷贝，而不是值本身）。
exception声明用于指定函数抛出的异常，如抛出整数类型的异常，可以使用throw (int)。
四、返回值类型，标识函数返回值的类型，当返回值为void，或者函数体中只有一处return的地方（此时编译器可以自动推断出返回值类型）时，这部分可以省略。
五、{函数体}，标识函数的实现，这部分不能省略，但函数体可以为空。
3. ScopeGuard的实现
有了上面的基础，我们就可以根据相关知识来实现ScopeGuard的了，具体实现如下：
class ScopeGuardBase {public:inline void Dismiss () noexcept { dismissed_ = true; }protected:ScopeGuardBase () : dismissed_ (false) { }ScopeGuardBase (ScopeGuardBase&& other): dismissed_ (other.dismissed_) {other.dismissed_ = true;}
bool dismissed_;};
template <typename FuncT>class ScopeGuardImpl : public ScopeGuardBase {public:explicit ScopeGuardImpl (const FuncT& func) : function_ (func) { }explicit ScopeGuardImpl (FuncT&& func) : function_ (std::move (func)) { }ScopeGuardImpl (ScopeGuardImpl&& other): ScopeGuardBase (std::move (other)), function_ (std::move (other.function_)) {other.dismissed_ = true;}~ScopeGuardImpl () {if (!dismissed_) {function_ ();}}private:void* operator new(size_t) = delete;FuncT function_;};
typedef ScopeGuardBase&& ScopeGuard;
看到这里你可能已经明白大概了，其实现原理就是利用析构函数来执行注册进来的func函数，以达到释放资源的目的。继续看下面的代码：
enum class ScopeGuardOnExit {};template <typename FuncT>
ScopeGuardImpl<typename std::decay
operator+ (ScopeGuardOnExit, FuncT&& func) {
return ScopeGuardImpl<typename std::decay
std::forward
}
template <typename FuncT>
ScopeGuardImpl<typename std::decay
MakeScopeGuard (FuncT&& func) {
return ScopeGuardImpl<typename std::decay
std::forward
}
// define a anonymous variables with the code line and a str
#ifndef SWIFT_ANONYMOUS_VARIABLES
#define SWIFT_ANONYMOUS_VARIABLES_IMPL(s1, s2) s1##s2
#define SWIFT_ANONYMOUS_VARIABLES(str) SWIFT_ANONYMOUS_VARIABLES_IMPL(str, __LINE__)
#endif
#ifndef SCOPE_GUARD_VARIABLES_AUTO_RUNNING_ON_EXIT
#define SCOPE_GUARD_VARIABLES_AUTO_RUNNING_ON_EXIT \
auto SWIFT_ANONYMOUS_VARIABLES(SCOPE_GUARD_EXIT_STATE) \
= ScopeGuardOnExit () + [&]() noexcept
#endif
一般情况下，我们会隐藏ScopeGuardImpl的实现，使得外界无法调用，因此我们提供MakeScopeGuard函数来创建ScopeGuard对象。为了使用方便提供宏
SCOPE_GUARD_VARIABLES_AUTO_RUNNING_ON_EXIT来处理，使用方法如下：
SCOPE_GUARD_VARIABLES_AUTO_RUNNING_ON_EXIT {
// your code to release some resource.
}；
下面来看一个读写文件的例子：
template <class Container>
bool ReadFile (const char *file_name,
Container& out,
size_t num_bytes = std::numeric_limits::max ()) {
static_assert(sizeof(out[0]) == 1, "ReadFile: only containers with byte-sized elements accepted");
assert (file_name);
const int fd = ::open (file_name, O_RDONLY);
if (-1 == fd) { return false; }
size_t size = 0;
SCOPE_GUARD_VARIABLES_AUTO_RUNNING_ON_EXIT {
assert (out.size () >= size);
out.resize (size);
Close (fd);
};
// Get file size
struct stat buf;
if (-1 == ::fstat (fd, &buf)) { return false; }
// Some files (notably under /proc and /sys on Linux) lie about
// their size, so treat the size advertised by fstat under advise
// but don't rely on it. In particular, if the size is zero, we
// should attempt to read stuff. If not zero, we'll attempt to read
// one extra byte.
const size_t initial_alloc = 1024 * 4;
out.resize (std::min (buf.st_size > 0 ? static_cast(buf.st_size + 1) : initial_alloc,
num_bytes));
while (size < out.size ()) {
size_t n = read (fd, &out[size], out.size () - size);
if (-1 == n) { return false; }
size += n;
if (size < out.size ()) { break; }
// Ew, allocate more memory. Use exponential growth to avoid
// quadratic behavior. Cap size to num_bytes.
out.resize (std::min (out.size () * 3 / 2, num_bytes));
}
return true;
}
该例子中使用SCOPE_GUARD_VARIABLES_AUTO_RUNNING_ON_EXIT宏定义了一个局部变量，变量析构时会自动调用关闭文件描述符的函数，因此使得代码更加简洁明了。更详细的使用方式，请参考https://github.com/ApusApp/Swift/tree/master/swift/base/scopeguard.h的实现及其单元测试。
参考
[1]. http://www.cnblogs.com/hujian/archive/2012/02/14/2350306.html