¿Cómo puede ser útil sobrecargar el operador de "llamada a la función"?

Hay poco más que una ganancia sintáctica al usar operator() hasta que comiences a usar plantillas. Pero cuando se utilizan plantillas se puede tratar las funciones reales y los funtores (clases que actúan como funciones) de la misma manera.

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) );

A un algoritmo implementado usando una plantilla no le importa si la cosa que se llama es una función o un funtor, le importa la sintaxis. Ya sea estándar (por ejemplo, for_each ()) o el suyo propio. Y los funtores pueden tener estado, y hacer todo tipo de cosas cuando se les llama. Las funciones solo pueden tener estado con una variable local estática o variables globales.

Si está creando una clase que encapsula un puntero de función, esto podría hacer que el uso sea más obvio.

El compilador también puede insertar el funtor y la llamada a la función. Sin embargo, no puede insertar un puntero de función. De esta manera, el uso del operador de llamada de función puede mejorar significativamente el rendimiento cuando se utiliza, por ejemplo, con los algoritmos libary estándar de C++.

Por ejemplo para implementar generadores:

// 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;
}

Veo potencial para todavía un uso exótico:

Supongamos que tiene un objeto de tipo desconocido y tiene que declarar otra variable del mismo tipo, así:

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

Cuando este patrón se usa ampliamente, decltype se vuelve muy molesto. Este caso puede ocurrir cuando se utiliza algún sistema de tipo inteligente que inventa automáticamente el tipo de resultado de funciones y operadores basados en tipos de argumentos.

Ahora, si cada especialización de cada tipo de ese tipo de sistema equipado con definición mágica de operator() así:

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

decltype() no más necesario, puede escribir simplemente:

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

Porque operator() del objeto redirige a constructor de su propio tipo.