前述：

go 中defer 给出了一种，延时调用的方式来释放资源。但是对于C/C++去没有内置的这种属性。对于经常手动管理内存的C/C++有其是C程序员这种特性显得无比重要。这里给出了一种基于GCC/Clang 编译器扩展属性（cleanup）来模拟实现defer的一种方式。

头文件如下：（我只对C/C++在GCC/CLANG Linux 平台做了测试，Object-C没有测试）

#ifndef __SCOPEGUARD_H__

#define __SCOPEGUARD_H__

#define __SCOPEGUARD_CONCATENATE_IMPL(s1, s2) s1##s2

#define __SCOPEGUARD_CONCATENATE(s1, s2) __SCOPEGUARD_CONCATENATE_IMPL(s1, s2)

#if defined(__cplusplus)

#include <type_traits>

// ScopeGuard for C++11

namespace clover

{

template <typename Fun>

class ScopeGuard

{

public:

    ScopeGuard(Fun &&f) : _fun(std::forward<Fun>(f)), _active(true) {}

    ~ScopeGuard()

    {

        if (_active)

        {

            _fun();

        }

    }

    void dismiss() { _active = false; }

    ScopeGuard() = delete;

    ScopeGuard(const ScopeGuard &) = delete;

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

    ScopeGuard(ScopeGuard &&rhs) : _fun(std::move(rhs._fun)), _active(rhs._active) { rhs.dismiss(); }

private:

    Fun _fun;

    bool _active;

};

namespace detail

{

enum class ScopeGuardOnExit

{

};

template <typename Fun>

inline ScopeGuard<Fun> operator+(ScopeGuardOnExit, Fun &&fn)

{

    return ScopeGuard<Fun>(std::forward<Fun>(fn));

}

} // namespace detail

} // namespace clover

// Helper macro

#define DEFER                                                 \

    auto __SCOPEGUARD_CONCATENATE(ext_exitBlock_, __LINE__) = \

        clover::detail::ScopeGuardOnExit() + [&]()

#elif defined(__APPLE__)

/* ScopeGuard for Objective-C */

typedef void (^ext_cleanupBlock_t)(void);

static inline void ext_executeCleanupBlock(__strong ext_cleanupBlock_t *block) { (*block)(); }

#define DEFER                                                                      \

    __strong ext_cleanupBlock_t __SCOPEGUARD_CONCATENATE(ext_exitBlock_, __LINE__) \

        __attribute__((cleanup(ext_executeCleanupBlock), unused)) = ^

#elif (defined(__linux__) || defined(__ANDROID__)) && !defined(__llvm__)

/**

 * Linux(HOST) GCC does not support extension 'blocks' and keyword '__strong'

 * So, just use cleanup in plain way

 */

#define DEFER(expr)                                      \

    void __SCOPEGUARD_CONCATENATE(__FUNC_, __LINE__)(void *_arg) \

    {                                                            \

        (void)_arg;                                              \

        expr                                                     \

    }                                                            \

    int __USELESS_V __attribute__((cleanup(__SCOPEGUARD_CONCATENATE(__FUNC_, __LINE__))));

#endif

#endif //__SCOPEGUARD_H__

测试：

不需要过多的解释，直接看执行结果就知道了。当超出作用域（break，goto，return）之后，会自动调用指定的内存释放函数（当然这里也可以用其他函数来代替）。（）

C++：

#include <iostream>

#include <string>

#include "scopeguard.h"

using namespace std;

int main()

{

    string *as = new string("hello world!");

    DEFER

    {

        cout << "in scope guard" << endl;

        delete as;

    };

    cout << "at end" << endl;

    return 0;

}

$ c++ xx.c

$ ./a.out

at end

in scope guard

C：

#include <stdio.h>

int main(int argc, char **argv)

{

    {

        DEFER(

            printf("call defer\n");

        );

        printf("will quit scope\n");

    }

    printf("before return\n");

    return 0;

}

$ cc xx.c

$ ./a.out

will quit scope

call defer

before return

需要注意的是这里DEFER 宏展开后会发现，这里发生了函数的嵌套定义，经测试Clang 不支持函数嵌套定义，应次在头文件添加了对 __llvm__ Clang独有编译器宏的判断。

此上C代码不能在安装Clang的Linux下编译（OSX不在此考虑范围，参考头文件__APPLE__宏）

参考：

https://zhuanlan.zhihu.com/p/21303431

https://zhuanlan.zhihu.com/p/35191739

defer

defer implement for C/C++ using GCC/Clang extension

前述：

测试：

参考：