Was ist der Unterschied zwischen verschiedenen Arten, eine Funktion als Argument an eine andere Funktion zu übergeben?

Ich habe die Situation, dass eine Funktion eine von mehreren möglichen Funktionen aufruft. Dies scheint ein guter Ort zu sein, um eine Funktion als Parameter zu übergeben. In dieser Quoara-Antwort von Zubkov gibt es drei Möglichkeiten, dies zu tun.

int g(int x(int)) { return x(1); }
int g(int (*x)(int)) { return x(1); }
int g(int (&x)(int)) { return x(1); }
...
int f(int n) { return n*2; }
g(f); // all three g's above work the same

Wann sollte welche Methode angewendet werden? Was gibt es Unterschiede? Ich bevorzuge den einfachsten Ansatz. Warum sollte nicht immer der erste Weg verwendet werden?

In meiner Situation wird die Funktion nur einmal aufgerufen und ich möchte sie einfach halten. Ich habe es mit Pass-by-Zeiger arbeiten und ich rufe es einfach mit g(myFunc)wo myFuncist die Funktion, die zuletzt aufgerufen wird.

Wenn Sie den Kommentar von LF erweitern, ist es oft besser, Funktionszeiger vollständig zu meiden und in Bezug auf aufrufbare Objekte (Dinge, die definieren operator()) zu arbeiten. Mit all den folgenden Optionen können Sie dies tun:

#include <type_traits>

// (1) unrestricted template parameter, like <algorithm> uses
template<typename Func>
int g(Func x) { return x(1); }

// (2) restricted template parameter to produce possibly better errors
template<
    typename Func,
    typename=std::enable_if_t<std::is_invocable_r_v<int, Func, int>>
>
int g(Func x) { return std::invoke(x, 1); }

// (3) template-less, trading a reduction in code size for runtime overhead and heap use
int g(std::function<int(int)> x) { return x(1); }

Wichtig ist, dass all diese Funktionen für Lambda-Funktionen mit Captures verwendet werden können, im Gegensatz zu Ihren Optionen:

int y = 2;
int ret = g([y](int v) {
    return y + v;
});