Qual é a diferença entre diferentes maneiras de passar uma função como argumento para outra função?

Eu tenho a situação em que uma função chama uma das várias funções possíveis. Este parece ser um bom lugar para passar uma função como parâmetro. Nesta resposta quoara de Zubkov, existem três maneiras de fazer isso.

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

Quando deve ser usado o método? Quais são as diferenças? Prefiro a abordagem mais simples, por que a primeira maneira nem sempre deve ser usada?

Para minha situação, a função é chamada apenas uma vez e eu gostaria de mantê-la simples. Eu tenho que trabalhar com passar pelo ponteiro e eu apenas chamo com g(myFunc)onde myFuncé a função que é chamada por último.

Expandindo o comentário de LF, geralmente é melhor evitar completamente os ponteiros de função e trabalhar em termos de objetos invocáveis ​​(coisas que definem operator()). Todos os seguintes permitem que você faça isso:

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

É importante ressaltar que tudo isso pode ser usado em funções lambda com capturas, diferente de qualquer uma das suas opções:

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