Question

使用C ++ 11，我们可以获得lambdas，并且可以在我们实际需要的地方即时创建函数/仿函数/闭包，而不是它们实际上不属于的地方。
在C ++ 98/03中，一个很好的方法来创建函数本地函子/闭包将是如下：

struct{
  void operator()(int& item){ ++item; }
}foo_functor;
some_templated_func(some_args, foo_functor);

可悲的是，您不能将本地类型用于模板（Visual Studio允许在启用语言扩展的情况下使用此类型）。然后，我的列车通过以下方式：

struct X{
  static void functor(int& item){ ++item; }
};
some_templated_func(some_args, &X::functor);

显而易见的问题是，你无法保存任何状态，因为本地结构/类不能有静态成员我下一步想到解决这个问题的方法是混合使用std::bind1st和std::mem_fun以及非静态方法＆amp;变量，但不幸的是std::mem_fun以某种方式与std::mem_fn(&X::functor)窒息，这可能是因为本地结构/类不能在模板中使用：

// wanted, not working solution
struct X{
  int n_;
  X(int n) : n_(n) {}
  void functor(int& item) const { item += n_; }
};
X x(5);
some_templated_func(some_args,std::bind1st(std::mem_fun(&X::functor),&x));

VC9＆amp; VC10（带/Za，禁用语言扩展名），错误如下

error C2893: Failed to specialize function template 'std::const_mem_fun1_t<_Result,_Ty,_Arg> std::mem_fun(_Result (_Ty::* )(_Arg) const)'
With the following template arguments:
'void'
'main::X'
'int &'

或者在gcc 4.3.4下出现此错误

error: no matching function for call to ‘mem_fun(void (main()::X::*)(int&))’

有趣的是，VC9 / VC10仍然在上面的例子中窒息，即使语言扩展允许：

error C2535: 'void std::binder1st<_Fn2>::operator ()(int &) const' : member function already defined or declared

那么，无论如何，标题中所述的功能是否可以实现？或者我在最后一个示例中使用std::bind1st或std::mem_fun时出错？

Answer 1

bind1st仅适用于二进制函数，通常它非常有限。 mem_fn仅适用于非静态成员函数;对于您的应用程序，您需要ptr_fun。

对于C ++ 03中的工作来说，最好的工具是Boost Bind，或者我将使用tr1::bind来证明这一点（在我看来）更便携。

#include <tr1/functional>
#include <iostream>
#include <algorithm>

using namespace std::tr1::placeholders;

int nums[] = { 1, 2, 4, 5, 6, 8 };

int main() {
    struct is_multiple {
        static bool fn( int mod, int num ) { return num % mod == 0; }
    };

    int *n = std::find_if( nums, nums + sizeof nums/sizeof*nums,
                        std::tr1::bind( is_multiple::fn, 3, _1 ) );

    std::cout << n - nums << '\n';
}

Answer 2

是的，你可以，但你必须实现一个或多个在接口中声明的虚方法。

template<typename Arg, typename Result>
struct my_unary_function
{
    virtual Result operator()(Arg) = 0;
};

template<typename Arg, typename Result>
struct my_unary_functor
{
    my_unary_function<Arg, Result> m_closure;
    my_unary_functor(my_unary_function<Arg, Result> closure) : m_closure(closure) {}
    Result operator()(Arg a) { return m_closure(a); }
};

template<typename T, TFunctor>
void some_templated_function( std::vector<T> items, TFunctor actor );

然后你可以定义和使用一个本地闭包：

void f()
{
    std::vector<int> collection;

    struct closure : my_unary_function<int, int>
    {
        int m_x, m_y;
        closure(int x, int y) : m_x(x), m_y(y) {}
        virtual int operator()(int i) const { cout << m_x + m_y*i << "\t"; return (m_x - m_y) * i; }
    };

    some_templated_function( collection, my_unary_functor<int,int>(closure(1, 5)) );
}

归功于@Omnifarious这项改进（my_unary_functor不需要）：

void f()
{
    std::vector<int> collection;

    struct closure : my_unary_function<int, int>
    {
        int m_x, m_y;
        closure(int x, int y) : m_x(x), m_y(y) {}
        virtual int operator()(int i) const { cout << m_x + m_y*i << "\t"; return (m_x - m_y) * i; }
    };

    // need a const reference here, to bind to a temporary
    const my_unary_functor<int,int>& closure_1_5 = my_unary_functor<int,int>(closure(1, 5))
    some_templated_function( collection, closure_1_5 );
}

Answer 3

如果这在C ++ 03中可行，为什么C ++ 0x会引入lambdas？存在lambdas的原因，这是因为绑定和所有其他C ++ 03解决方案都非常糟糕。

是否有可能在C ++ 11之前创建函数本地闭包？

3 个答案: