标签: function-object

是否可以std::function在C++中序列化和反序列化a ,函数对象或闭包？怎么样？C++ 11是否有助于此？是否有任何图书馆支持可用于此类任务(例如,在Boost中)？

例如,假设一个C++程序std::function需要与另一台机器上的另一个C++程序进行通信(比如通过TCP/IP套接字).在这种情况下你有什么建议？

为了澄清,要移动的功能应该是纯粹的,没有副作用的.所以我没有安全性或状态不匹配问题.

该问题的解决方案是构建一个小的嵌入式域特定语言并序列化其抽象语法树.我希望我能找到一些语言/库支持来代替移动与机器无关的函数表示.

How to overload a simple local lambda function?

SSE of original problem:

#include <iostream>
#include <map>

void read()
{
    static std::string line;
    std::getline(std::cin, line);

    auto translate = [](int idx)
    {
        constexpr static int table[8]{ 7,6,5,4,3,2,1,0 };
        return table[idx];
    };

    auto translate = [](char c)
    {
        std::map<char, int> table{ {'a', 0}, {'b', 1}, {'c', 2}, {'d', 3},
                                             {'e', 4}, {'f', 5}, {'g', 6}, {'h', 7} };
        return table[c];
    };

    int r = translate(static_cast<int>(line[0]));
    int c = translate(static_cast<char>(line[1]));
    std::cout << r << …

这个工作的关键原因是for_each()实际上并没有假设 它的第三个参数是一个函数.它只是假设它的第三个参数是可以用适当的参数调用的东西.适当定义的对象与 - 函数一样 - 并且通常比 - 更好.例如,内联类的应用程序操作符比内联作为函数指针传递的函数更容易.因此,函数对象通常比普通函数执行得更快.具有应用程序运算符(第11.9节)的类的对象称为类似函数的对象,仿函数或简称为函数对象.

[Stroustrup,C++第3版,18.4-最后一段]

1. 我一直认为operator()调用就像在运行时调用函数一样.它与普通函数调用有什么不同？

2. 为什么内联应用程序操作符比正常函数更容易？

3. 它们如何比函数调用更快？

我喜欢在javascript中,我可以创建一个函数,然后向该函数添加更多的方法和属性

myInstance = function() {return 5}
myInstance.attr = 10

我想创建一个类来生成这些对象.我假设我必须从Function基类继承.

换句话说,我想:

var myInstance = new myFunctionClass()
var x = myInstance()
// x == 5

但我不知道如何创建myFunctionClass.我尝试了以下,但它不起作用:

var myFunctionClass = function() {Function.call(this, "return 5")}
myFunctionClass.prototype = new Function()
myInstance = new myFunctionClass()
myInstance()
// I would hope this would return 5, but instead I get
// TypeError: Property 'myInstance' of object #<Object> is not a function

我还试过这里找到的更复杂(也更合适？)的继承方法:如何在JavaScript中"正确"创建自定义对象？,没有更多的运气.我也尝试使用node.js中的util.inherits(myFunctionClass,Function).仍然没有运气

我已经筋疲力尽了谷歌,因此我觉得我必须遗漏一些基本或明显的东西.非常感谢帮助.

在重载解析期间,函数对象是否与常规函数区别对待？如果是这样,怎么样？

我遇到了以下情况:用等效可调用函数对象替换函数改变了代码的含义:

#include <iostream>

namespace N
{
    enum E { A, B };

    void bar(E mode) { std::cout << "N::bar\n"; }
}

template <typename... Args>
void bar(Args&&... args) { std::cout << "global bar\n"; }

int main()
{
    bar(N::A);
}

这里的输出是"N :: bar".到目前为止,非常好:ADL找到N :: bar,N :: bar和全局条都是精确匹配,N :: bar是首选,因为它不是模板.

但是如果我将全局条改变为函数对象,就像这样:

#include <iostream>

namespace N
{
    enum E { A, B };

    void bar(E mode) { std::cout << "N::bar\n"; }
}

struct S
{
    template <typename... Args>
    void operator()(Args&&... args) { std::cout …

我看到函数对象经常与STL算法一起使用.功能对象是否因为这些算法而出现？你什么时候在C++中使用函数对象？它的好处是什么？

在C++标准模板库中,有一个"功能"部分,其中许多类使其()运算符超载.

在C++中使用函数作为对象是否带来任何便利？

为什么我们不能只使用函数指针呢？任何例子？

我有两个与函数对象和函数指针相关的问题,

问题:1

当我读到sortSTL 的不同用途算法时,我看到第三个参数可以是一个函数对象,下面是一个例子

class State {  
  public:  
    //...
    int population() const;  
    float aveTempF() const;  
    //...  
};    
struct PopLess : public std::binary_function<State,State,bool> {  
    bool operator ()( const State &a, const State &b ) const  
        { return popLess( a, b ); }  
};  
sort( union, union+50, PopLess() );  

题 :

现在,声明怎么样sort(union, union+50,PopLess())？PopLess()必须解析成PopLess tempObject.operator()与operator ()在临时对象上执行函数相同的东西.我将此视为,将重载操作的返回值bool(如我的示例中)传递给sort算法.

那么,在这种情况下,sort函数如何解析第三个参数？

问题2

题

我们是否使用函数对象与函数指针相比​​具有任何特定优势？如果我们使用下面的函数指针它会导致任何不利吗？

inline bool popLess( const State &a, const State &b …

我应该如何使用doxygen记录函数对象(AKA仿函数)？将其记录为普通班级会让人觉得误导.我发现将函数对象视为具有闭包的函数比使用可调用类更好.

有没有办法记录符合我的偏好的函数对象？

class Adder
{
public:
   Adder( size_t x ) :
      m_x(x)
   { }

   size_t operator () ( size_t y ) const
   {
      return m_x + y;
   }

private:
   const size_t m_x;
};

标准库函数对象的通常模式是使用带有非模板的模板化结构operator().例如,std::less看起来像这样:

template <typename T>
struct less
{
    bool operator()(const T& lhs, const T& rhs) const {
        return lhs < rhs;
    }
};

std::vector<float> vec  = ...;
std::sort(vec.begin(), vec.end(), less<float>{});

我的问题是,为什么这比带有模板化的非模板结构更好operator()？似乎上面的仿函数在操作上等同于:

struct less2
{
    template <typename T>
    bool operator()(const T& lhs, const T& rhs) const {
        return lhs < rhs;
    }
};

std::vector<float> vec = ...;
std::sort(vec.begin(), vec.end(), less2{});

除了我们获得自动类型扣除奖金.更好的是,如果我们想要,我们可以比较不同的类型,只要它有意义:

struct less
{
    template <typename T, typename U>
    bool operator()(const T& lhs, const U& rhs) …