第25课 可变参数模板（6）_function_traits和ScopeGuard的实现

#ifndef _FUNCTION_TRAITS_H_
#define _FUNCTION_TRAITS_H_

#include <functional>
#include <tuple>

//普通函数
//函数指针
//function/lambda
//成员函数
//函数对象

template<typename T>
struct function_traits;   //前向声明

//普通函数
template<typename Ret, typename... Args>
struct function_traits<Ret(Args...)>
{
public:
    enum {arity = sizeof...(Args)};//arity : 参数的数量

    //函数别名
    typedef Ret function_type(Args...); //<==> using function_type = Ret(Args...);
    
    typedef Ret return_type; //返回值类型
    using stl_function_type = std::function<function_type>;
    typedef Ret(*pointer)(Args...);

    //获取可变参数模板中第I个位置的参数类型。
    template<size_t I, class = typename std::enable_if<(I<arity)>::type>
    using args = typename std::tuple_element<I, std::tuple<Args...>>;
};

//函数指针
template<typename Ret, typename... Args>
struct function_traits<Ret(*)(Args...)> : function_traits<Ret(Args...)>{};

//std::function
template<typename Ret, typename... Args>
struct function_traits<std::function<Ret(Args...)>> : function_traits<Ret(Args...)>{};

//成员函数
#define FUNCTION_TRAITS(...)   \
template <typename ReturnType, typename ClassType, typename... Args>  \
struct function_traits<ReturnType(ClassType::*)(Args...) __VA_ARGS__> : function_traits<ReturnType(Args...)>{};

FUNCTION_TRAITS()
FUNCTION_TRAITS(const)   //const成员函数
FUNCTION_TRAITS(volatile)
FUNCTION_TRAITS(const volatile)

//函数对象
template<typename Callable>
struct function_traits :  function_traits<decltype(&Callable::operator())>{};

//将lambda转为std::function
template<typename Function>
typename function_traits<Function>::stl_function_type
to_function(const Function& lambda)
{
    return static_cast<typename function_traits<Function>::stl_function_type>(std::forward<Function>(lambda));
}

template<typename Function>
typename function_traits<Function>::stl_function_type
to_function(Function&& lambda)
{
    return static_cast<typename function_traits<Function>::stl_function_type>(lambda);
}

//将lambda转为函数指针,如
template<typename Function>
typename function_traits<Function>::pointer
to_function(const Function& lambda)
{
    //    typedef int(*FUN)(int);
    //    auto f = FUN([](int x){return x + 10;});
    //  cout << f(10) << endl;  //20
    return static_cast<typename function_traits<Function>::pointer>(lambda);
}

#endif  //_FUNCTION_TRAITS_H_

#include <iostream>
#include <typeinfo>
#include "function_traits.hpp"

using namespace std;

template<typename T>
void PrintType()
{
    cout << typeid(T).name() << endl;
}

float (*castfunc)(string, int);
float free_function(const string& a, int b)
{
    return (float) a.size() / b;
}

struct Test
{
    int func(int a, int b) volatile
    {
        return a + b;
    }

    int operator()(int) const
    {
        return 0;
    }
};

void TestFunctionTraits()
{
    std::function<int(int)> f = [](int a){return a;};
    PrintType<function_traits<std::function<int(int)>>::function_type>();  //FiiE
    PrintType<function_traits<std::function<int(int)>>::args<0>::type>();    //i
    PrintType<function_traits<decltype(f)>::function_type>();
    PrintType<function_traits<decltype(free_function)>::function_type>();

    PrintType<function_traits<decltype(castfunc)>::function_type>();

    PrintType<function_traits<Test>::function_type>(); //FiiE, int operator()(int)
    using T = decltype(&Test::func);
    PrintType<T>();  //M4TestVFiiiE
    
    PrintType<function_traits<decltype(&Test::func)>::function_type>(); //FiiiE
    
    cout << std::is_same<function_traits<decltype(f)>::return_type, int>::value << endl; //1
}

int main()
{
    typedef int(*FUN)(int);
    auto f = FUN([](int x){return x + 10;});
    cout << f(10) << endl;

    TestFunctionTraits();

    return 0;
}
/*
//g++测试结果
E:\Study\C++11\25>g++ -std=c++11 test_function_traits.cpp
E:\Study\C++11\25>a.exe
20
FiiE
i
FiiE
FfRKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiE
FfNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEiE
FiiE
M4TestVFiiiE
FiiiE
1

//VC2015测试结果：
e:\Study\C++11\25>cl test_function_traits.cpp /EHsc
e:\Study\C++11\25>test_function_traits.exe
20
int __cdecl(int)
int
int __cdecl(int)
float __cdecl(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> > const &,int)
float __cdecl(class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int)
int __cdecl(int)
int (__thiscall Test::*)(int,int)volatile
int __cdecl(int,int)
1
*/

#ifndef _SCOPE_GUARD_H_
#define _SCOPE_GUARD_H_

#include <iostream>
using namespace std;

template <typename F>
class ScopeGuard
{
   F m_func; //异常处理函数
   bool m_dismiss; //正常退出为true，非正常退出时为false
   
   ScopeGuard();
   ScopeGuard(const ScopeGuard&);
   ScopeGuard& operator=(const ScopeGuard&);
public:
    void dismiss()
    {
        m_dismiss = true;
    }

    explicit ScopeGuard(F&& f) : m_func(f), m_dismiss(false){}
    explicit ScopeGuard(const F& f) : m_func(f), m_dismiss(false){}

    ScopeGuard(ScopeGuard&& rhs) : m_func(std::move(rhs.m_func)),
                                   m_dismiss(rhs.m_dismiss)
    {
        rhs.dismiss();
    }

    ~ScopeGuard()
    {
        if(!m_dismiss && m_func != nullptr){
            m_func();
        }
    }
};

//辅助函数
template<typename Function>
ScopeGuard<typename std::decay<Function>::type> MakeGuard(Function&& f)
{
    //调用ScopeGuard(const F& f)或ScopeGuard(F&& f)
    return ScopeGuard<typename std::decay<Function>::type>(std::forward<Function>(f)); 
}

#endif

#include <iostream>
#include <functional>
#include <exception>
#include "ScopeGuard.hpp"

using namespace std;

void TestScopeGuard()
{
    //资源清理函数
    std::function<void()> f = []{cout << "clean up from unnormal exit" << endl;};

    //正常退出
    {
        auto gd = MakeGuard(f);

        //... 在MakeGuard和dismiss之间的操作是异常安全的。一旦出现导常，导致gd在
        //    离开作用域时，会调用传入在MakeGuard中注册的清理函数进行释放资源。
        
        gd.dismiss(); //解除ScopeGuard
    }

    //异常退出
    {
        auto gd = MakeGuard(f);

        //... 其它操作，假设在这里出现异常。由于这里的代码被MakeGuard保护
        //所以异常发生时，仍会调用清理函数来正确释放资源
        throw std::exception(std::out_of_range("excetion occur!"));

        gd.dismiss(); 
    }

    //非正常退出
    {
        auto gd = MakeGuard(f);

        return;

        gd.dismiss(); 
    }    
}

int main()
{
    TestScopeGuard();
    return 0;
}