¿Cuál es la diferencia entre las diferentes formas de pasar una función como argumento a otra función?

Tengo la situación en la que una función llama a una de varias funciones posibles. Este parece ser un buen lugar para pasar una función como parámetro. En esta respuesta de Quoara de Zubkov hay tres formas de hacer esto.

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

¿Cuándo se debe utilizar qué método? ¿Qué hay diferencias? Prefiero el enfoque más simple, ¿por qué no debería usarse siempre la primera forma?

Para mi situación, la función solo se llama una vez y me gustaría que sea simple. Lo tengo trabajando con pasar por puntero y simplemente lo llamo con g(myFunc)dónde myFuncestá la función que se llama al último.

Ampliando el comentario de LF, a menudo es mejor evitar por completo los punteros de función y trabajar en términos de objetos invocables (cosas que definen operator()). Todo lo siguiente le permite hacer eso:

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

Es importante destacar que todos estos pueden usarse en funciones lambda con capturas, a diferencia de cualquiera de sus opciones:

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