c++11函数完美转发之异常处理

什么是完美转发？网上资料很多，简单总结一下，就是通过函数参数传递给函数里面的另外一个函数时，参数的属性不能变化，原来是左值的还得是左值，原来是右值的还得是右值。

左值比较简单，默认就是，关键是这右值，当一个右值当作参数传递给另外一个函数时，这个右值便有了自己的名字，于是变成了左值，这才是问题所在。

funtion(左值) {
    forward(左值)
}

funtion(右值) {
    forward(右值)
}

我们要让它进入转发的目标函数参数时也是右值才行，这里需要用到特殊引用和std::forward来解决问题，另外需要了解什么是引用折叠。

异常处理

其实，这算是一个需求，当某些函数运行过程中可能会跑出异常时，那么我们需要做catch的操作，否则程序奔溃。

那么我想在调用这个函数时就做try catch操作，做一个包装函数，后续调用这个包装函数就行，这个包装函数保证是不抛异常的。

可以通过入下实现：

#include <iostream>
#include <memory>

#define WARP_CALL(fun, ...)             \
do {                                    \
    try {                               \
        return fun(__VA_ARGS__);        \
    } catch(...) {                      \
                                        \
    }                                   \
} while(false)

template<class Fun, class... Args>
auto wrap_call(Fun&& f, Args&&... args) noexcept
    -> decltype(std::forward<Fun>(f)(std::forward<Args>(args)...))
{
    try {
        std::cout << "get" << std::endl;
        return std::forward<Fun>(f)(std::forward<Args>(args)...);
    } catch (...) {
        std::cout << "error" << std::endl;
    }
}


template<class C, class Fun, class... Args>
auto wrap_call(C&& obj, Fun&& f, Args&&... args) noexcept
    -> decltype((std::forward<C>(obj)->*std::forward<Fun>(f))(std::forward<Args>(args)...))
{
    try {
        std::cout << "get" << std::endl;
        return (std::forward<C>(obj)->*std::forward<Fun>(f))(std::forward<Args>(args)...);
    } catch (...) {
        std::cout << "error" << std::endl;
    }
}

class FuncFactory
{
public:
    FuncFactory() = default;
    int test(int a, int b)
    {
        std::cout << "aaa: " << a << " b: " << b << std::endl;
        // throw -1;
        return a + b;
    }

    void test2(int a, int b)
    {
        std::cout << "a2: " << a << " b2: " << b << std::endl;
        // throw -1;
    }

    double test3(int a, int b)
    {
        std::cout << "a: " << a << " b: " << b << std::endl;
        // throw -1;
        return a + b;
    }
};

double bbb(int a, int b)
{
    std::cout << "a: " << a << " b: " << b << std::endl;
    // throw -1;
    return a + b;
}

int main()
{
    int a = 3;
    int b = 9;
    // WARP_CALL(bbb, a, b);
    FuncFactory yf;
    int res = wrap_call(bbb, a, b);
    std::cout << "result: " << res << std::endl;
    res = wrap_call(&yf, &FuncFactory::test, a, b);
    std::cout << "result2: " << res << std::endl;
    std::shared_ptr<FuncFactory> yf_ptr(new FuncFactory);
    res = wrap_call(yf_ptr.get(), &FuncFactory::test, a, b);
    std::cout << "result3: " << res << std::endl;
}