重载“函数调用”有何用处？操作员？

Question

我最近发现，在 C++ 中，您可以以一种奇怪的方式重载“函数调用”运算符，其中您必须编写两对括号才能执行此操作：

class A { 
  int n;
public: 
  void operator ()() const; 
};

然后以这种方式使用它：

A a;
a();

这什么时候有用？

Answer 1

这可用于创建 "functors"，其行为类似于函数的对象：

class Multiplier {
public:
    Multiplier(int m): multiplier(m) {}
    int operator()(int x) { return multiplier * x; }
private:
    int multiplier;
};

Multiplier m(5);
cout << m(4) << endl;

上面的打印 20。上面链接的维基百科文章提供了更实质性的例子。

Answer 2

在开始使用模板之前，使用operator()只会带来语法上的好处。但是，当使用模板时，您可以以相同的方式对待实际函数和函子（充当函数的类）。

class scaled_sine
{
    explicit scaled_sine( float _m ) : m(_m) {}
    float operator()(float x) const { return sin(m*x); }
    float m;
};

template<typename T>
float evaluate_at( float x, const T& fn )
{
   return fn(x);
}

evaluate_at( 1.0, cos );
evaluate_at( 1.0, scaled_sine(3.0) );

Answer 3

使用模板实现的算法并不关心被调用的是函数还是仿函数，它关心的是语法。标准的（例如 for_each()）或您自己的。函子可以拥有状态，并在被调用时执行各种操作。函数只能具有静态局部变量或全局变量的状态。

Answer 4

例如，用于实现生成器：

// generator
struct Generator {
    int c = 0;

    virtual int operator()() {
        return c++;
    }
};

int sum(int n) {
    Generator g;

    int res = 0;
    for( int i = 0; i < n; i++ ) {
        res += g();
    }

    return res;
}

Answer 5

如果您正在创建一个封装函数指针的类，这可能会使用法更加明显。

Answer 6

编译器还可以内联函子和函数调用。但是，它不能内联函数指针。这样，当与标准 C++ 库算法一起使用时，使用函数调用运算符可以显着提高性能。

Answer 7

我看到了一种奇异用途的潜力：

假设您有未知类型的对象，并且必须声明相同类型的另一个变量，如下所示：

 auto c=decltype(a*b)(123);

当广泛使用这种模式时，decltype 变得非常烦人。
当使用某些智能类型系统时，可能会发生这种情况，该系统会根据参数类型自动创建函数和运算符的结果类型。

现在，如果该类型系统的每种类型的每个专精都配备了
operator() 的神奇定义是这样的：

template<????> class Num<???>{
    //specific implementation here
    constexpr auto operator()(auto...p){return Num(p...);}
}

不再需要 decltype() ，你可以简单地写：

auto c=(a*b)(123);

因为对象的operator()重定向到它自己类型的构造函数。