标签: function-object

下面的代码计算的特定属性的平均T中items收集:

public double Average<T>(IList<T> items, Func<T, double> selector)
{
    double average = 0.0;

    for (int i = 0; i < items.Count; i++)
    {
        average += selector(items[i])
    }

    return average / items.Count;
}

然后我可以用一个lambda表达式来调用它:

double average = Average(items, p => p.PropertyName);

我将如何在c ++中执行此操作？这是我到目前为止所拥有的:

template <typename T>
double average(const vector<T>& items, ?)
{
    double average= 0.0;

    for (int i = 0; i < items.size(); i++)
    {
        average += ?;
    }

    return average/ items.size();
}

我怎样才能用c ++调用它 …

问题:有没有办法在python中使用字符串创建一个函数对象？

信息:我正在开发一个项目,我将数据存储在sqlite3服务器后端.没什么可疯狂的.DAL类通常是通过代码生成完成的,因为代码是如此令人难以置信的平凡.但这给了我一个想法.在python中,当找不到属性时,如果定义函数" getattr ",它将在错误之前调用它.所以我想通过解析器和逻辑树的方式,我可以在第一次调用时动态生成我需要的代码,然后将函数对象保存为本地属性.例如:

DAL.getAll()

#getAll() not found, call __getattr__

DAL.__getattr__(self,attrib)#in this case attrib = getAll

##parser logic magic takes place here and i end up with a string for a new function

##convert string to function

DAL.getAll = newFunc

return newFunc

我已经尝试过编译功能,但exec和eval在能够完成这种壮举方面远非令人满意.我需要能够实现多种功能的东西.还有另一种方法可以做到这一点,除了那些不涉及将其写入磁盘？我再次尝试动态创建一个函数对象.

PS:是的,我知道这有可怕的安全和稳定性问题.是的,我知道这是一种非常有效的方法.我关心的？没有.这是一个概念证明."可以python这样做吗？它能动态创建一个函数对象 "是我想知道的,而不是一些优越的选择.(尽管在你回答了手头的问题之后可以自由地选择优秀的替代方案)

如何检测nullary和unary函数指针,std :: function对象和functor(包括lambdas)的返回类型和参数类型？

Boost的function_traits和功能特性并没有让我开箱即用,但我愿意补充或替换它们.

我可以这样做:

namespace nsDetail
{
    class Dummy { Dummy(); };
}

template<class Fn> struct FnTraits;

template<class R>
struct FnTraits<R(*)()>
{
    typedef nsDetail::Dummy ParamType;
    typedef R               ReturnType;
    typedef R Signature();
};

template<class R, class P>
struct FnTraits<R(*)(P)>
{
    typedef P ParamType;
    typedef R ReturnType;
    typedef R Signature( P );
};

template<class R>
struct FnTraits< std::function<R()> >
{
    typedef nsDetail::Dummy ParamType;
    typedef R               ReturnType;
    typedef R Signature();
};

template<class R, class P>
struct FnTraits< std::function<R(P)> …

如何从内部调用函数对象？似乎我无法使用this.例:

class factorial {
  public:
  int operator()(int n) {
    if (n == 0)
      return 1;
    return n * ??(n-1);
  }
};

我该放??什么？

这似乎应该经常被问及回答,但我的搜索功能让我失望了.

我正在编写一个函数,我想接受某种通用的可调用对象(包括裸函数,手动仿函数对象bind,或std::function),然后在算法深度(即lambda)中调用它.

该函数目前声明如下:

template<typename T, typename F>
size_t do_something(const T& a, const F& f)
{
   T internal_value(a);
   // do some complicated things
   // loop {
   //   loop {
       f(static_cast<const T&>(internal_value), other_stuff);
       // do some more things
   //   }
   // }
   return 42;
}

我通过引用接受仿函数,因为我想保证它不会在函数入口时被复制,因此实际调用了对象的相同实例.它是一个const引用,因为这是接受临时对象的唯一方法(这在使用手动仿函数时很常见bind).

但是这需要将functor实现operator()为const.我不想要那个; 我希望它能够接受两者.

我知道我可以声明这个方法的两个副本,一个接受它作为const,一个接受非const,以便涵盖这两种情况.但是我不想这样做,因为注释隐藏了很多我不想复制的代码(包括一些循环结构,所以我不能在不移动问题的情况下将它们提取到辅助方法) .

我也知道const_cast在调用它之前我可能会欺骗和非const的仿函数,但这感觉有潜在危险(特别是如果函子故意实现const和非const调用操作符,则会调用错误的方法).

我已经考虑过接受函子作为std::function/ boost::function,但这对于应该是一个简单的问题来说是一个重要的解决方案.(特别是在仿函数不做任何事情的情况下.)

有没有"正确"的方法来满足这些要求而不是复制算法？

[注意:我更喜欢不需要C++ 11的解决方案,尽管我也对C++ 11的答案感兴趣,因为我在两种语言的项目中都使用类似的结构.

我有一个接收函数对象的模板化函数.有时函数对象是无状态结构,但有时它们是大型有状态对象.函数对象的状态在此函数中未更改,仅进行了检查.我也非常热衷于编写编译器可以尽可能优化的代码.选择参数类型时我应该考虑什么？

该功能属于以下类型:

template<typename funcT>
auto make_particle(funcT fun) {
   Particle<typename funcT::result_type> particle;
   particle = fun();
   return particle;
}

参数类型可能应该是funcT const & fun大型对象不被复制,但为什么大多数人使用按值调用的函数对象？我是否通过使用const引用来松散？或者我应该使用左值参考？请注意,c ++ 1y没问题,上面的代码示例只是一个例子.

C++标准将函数对象定义为:

函数对象类型是一种对象类型,可以是函数调用中postfix-expression的类型.(链接)

首先,我在想,函数对象是仿函数,但后来我意识到,对于一个函数指针ptr类型的P(不是功能,而是一个函数指针)std::is_object_v<P>是true,可与被称为ptr(Args...)语法.

我认为函数指针被标准视为函数对象是对的吗？如果它们不是函数指针不满足定义的哪一部分？

// Fallback, anything with an operator()
template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())> > {
};

Run Code Online (Sandbox Code Playgroud)

这里是什么T::operator()意思？

这是来自 pytorch 的代码。

我正在寻找一个一元函子,它将取消引用它的参数并返回结果.当然我可以写一个,它似乎应该已经存在.

所以给出代码:

const auto vals = { 0, 1, 2, 3 };
vector<const int*> test(size(vals), nullptr);

iota(begin(test), end(test), data(vals));

transform(cbegin(test), cend(test), ostream_iterator<int>(cout, " "), [](const auto& i){ return *i; });

Live Example

我希望有一个我可以用而不是lambda的仿函数.这样的事情存在,还是我需要使用lambda？

考虑以下代码:

template<class F>
void foo1(F f) { f(); }

template<class F>
void foo2(F const& f) { f(); }

template<class F>
void foo3(F&& f) { f(); }

foo我应该使用哪个版本？foo1这是我在"野外"看到的最多,但我担心它可能会引入我不想要的副本.我有一个很复杂的自定义仿函数,所以我想避免这种情况.目前我倾向于foo3(因为foo2不允许变异的算子),但我不确定其含义.

我的目标是C++ 11.