ScopedExit实现:将参数传递给函数对象

时间:2013-06-04 12:26:39

标签: c++ c++11 function-pointers

我正在尝试实现简单的ScopedExit类。这是代码:

#include <iostream>
#include <functional>

template<class R, class... Args>
class ScopedExit
{
public:
    ScopedExit(std::function<R(Args...)> exitFunction)
    {
        exitFunc_ = exitFunction; 
    }

    ~ScopedExit()
    {
        exitFunc_();
    }
private:
    std::function<R(Args...)> exitFunc_;
};

template<>
class ScopedExit<void>
{
public:
    ScopedExit(std::function<void ()> exitFunction)
    {
        exitFunc_ = exitFunction; 
    }

    ~ScopedExit()
    {
        exitFunc_();
    }
private:
    std::function<void ()> exitFunc_;
};

void foo()
{
    std::cout << "foo() called\n";
}

class Bar
{
public:
    void BarExitFunc(int x, int y)
    {
        std::cout << "BarExitFunc called with x =" << x << "y = " << y << "\n";
    }
};

int main()
{
    Bar b;
    std::cout << "Register scoped exit func\n";
    {
        ScopedExit<void, int, int> exitGuardInner(std::bind(&Bar::BarExitFunc, &b, 18, 11));
    }
    ScopedExit exitGuardOutter(foo);
    std::cout << "About to exit from the scope\n";
    return 0;
}

所以,有几个问题:

  1. 如何将exit的函数参数传递给它?例如,我使用两个整数参数绑定BarExitFunc:18和11.那么如何将它传递给析构函数中的exitFunc_?我想我需要像std :: forward&lt;&gt;。

  2. 这样调用函数
  3. gcc 4.7.2(来自ideone.com)抱怨exitGuardOutter。它说:

  4.   

    prog.cpp:60:16:错误:在'exitGuardOutter'之前缺少模板参数

         

    prog.cpp:60:16:错误:在'exitGuardOutter'之前预期';'

    提前致谢。

2 个答案:

答案 0 :(得分:2)

  

如何将exit的函数参数传递给它?例如,我使用两个整数参数绑定BarExitFunc:18和11.那么如何将它传递给析构函数中的exitFunc_?

在析构函数的调用时,我没有理由将参数传递给exitFunc_。无论你做什么,你都必须在ScopedExit构造函数中预先提供这些参数。

最简单的方法就是在定义网站上使用function<R()>bind任何必需的参数,就像您已经在做的那样:

ScopedExit<R> guard(std::bind(someFunction, someArg, otherArg));

这使您可以完全摆脱可变参数模板参数,并简化模板很多


现在,如果困扰你的是你必须输入std::bind,你宁愿使用这样的语法:

ScopedExit<R> guard(someFunction, someArg, otherArg);

真的,我没有看到这一点,因为它使模板更复杂,但为什么不呢......只需绑定/转发构造函数本身的参数并仍然存储function<R()>

template<typename... Args>
ScopedExit(std::function<R(Args...)> exitFunction, Args&&... args)
{
    exitFunc_ = std::bind(exitFunction, std::forward<Args>(args)...); 
}

现在你系统地bind函数,即使没有绑定参数,所以你可能想要专门化你的类,以避免在没有参数时这个无用的bind。这是一个练习。


  

gcc 4.7.2(来自ideone.com)抱怨exitGuardOutter

这是因为foo不是std::function,编译器无法推断出正确的模板参数。正如@ForEveR已经提到的,您可以将保护变量定义为ScopedExit<void> guard(foo);

或者,将它全部包装并牢记我刚才所说的内容(bind最好不在你的模板中并在你的后卫的定义网站上使用)你可以摆脱构造函数中的std::function并概括任何仿函数(BTW,标准库在需要仿函数/回调时的行为)。对于存储,您可以使用std::function<void()>,因为它也接受非void返回类型:

class ScopedExit
{
public:
    template<typename Functor>
    ScopedExit(Functor exitFunction)
    {
        exitFunc_ = exitFunction; 
    }

    ~ScopedExit()
    {
        exitFunc_();
    }
private:
    std::function<void()> exitFunc_;
};

int foo() { return 0; }

struct Bar {
  void bye(int, int) {}
};

struct Baz {
  void operator ()() {}
};

int main() {
    const std::string what = "lambda!";
    ScopedExit guard1([&]() { std::cout << "yay a " << what << std::endl; });

    ScopedExit guard2(foo); // note how std::function<void()> accepts non-void return types

    Bar b;
    ScopedExit guard3(std::bind(&Bar::bye, &b, 1, 2));

    ScopedExit guard4(Baz());
}

注意你的原始可变参数模板类现在变成了一个灵活的非模板类,只有一个模板化的构造函数,其模板参数是自动推导出来的,几乎接受 [见下面的注释] 任何一种你可以考虑的仿函数。


注意:我说几乎任何仿函数,因为这不适用于默认参数:

void foobar(int = 0) {}
ScopedExit guard5(foobar); // error: too few arguments to function

即使您直接存储了Functor而不是std::function<void()>,您也无法使用默认参数(foobar的签名仍为{{1}即使使用默认参数)所以总是必须在定义站点处理这个角落的情况,例如:

void(int)

答案 1 :(得分:1)

1)例如,您可以在tuple中保存参数。但是,在您的情况下,您可以简单地调用exitFunc_(),函数定义应该是std::function<R()> exitFunction,因为您已经将参数绑定到函数。这样的事可能

#include <iostream>
#include <functional>
#include <tuple>

template<size_t...>
struct indices {};
template<size_t N, size_t... Is>
struct gen_indices : gen_indices<N - 1, N - 1, Is...>
{
};
template<size_t... Is>
struct gen_indices<0, Is...> : indices<Is...>
{
};

template<class R, class... Args>
class ScopedExit
{
public:
    ScopedExit(std::function<R(Args...)> exitFunction, Args&&... args)
    : arguments_(std::forward_as_tuple(args...))
    {
        exitFunc_ = exitFunction;
    }

    ~ScopedExit()
    {
       call(gen_indices<sizeof...(Args)>());
    }
private:
    template<size_t... Idx>
    void call(indices<Idx...>)
    {
       exitFunc_(std::forward<Args>(std::get<Idx>(arguments_))...);
    }
    std::tuple<Args...> arguments_;
    std::function<R(Args...)> exitFunc_;
};

template<>
class ScopedExit<void>
{
public:
    ScopedExit(std::function<void ()> exitFunction)
    {
        exitFunc_ = exitFunction; 
    }

    ~ScopedExit()
    {
        exitFunc_();
    }
private:
    std::function<void ()> exitFunc_;
};

void foo()
{
    std::cout << "foo() called\n";
}

class Bar
{
public:
    void BarExitFunc(int x, int y)
    {
        std::cout << "BarExitFunc called with x =" << x << "y = " << y << "\n";
    }
};

int main()
{
    Bar b;
    std::cout << "Register scoped exit func\n";
    {
        ScopedExit<void, int, int> exitGuardInner
        (
           std::bind(&Bar::BarExitFunc, &b, std::placeholders::_1, 
           std::placeholders::_2), 10, 18
        );
    }
    ScopedExit<void> exitGuardOutter(foo);
    std::cout << "About to exit from the scope\n";
    return 0;
}

2)应该像ScopedExit<void>一样创建。