Функция должна принять указатель на саму себя

int myfunc(int (*P)(int))  принимаю указатель на функцию
{
   return 0;
}
 
int main()
{
  int (*P)( int (*)(int) ); //создаю указатель на функцию
  P=myfunc; //присваиваю в указатель адрес функции
  myfunc(P); //попытка передарь функции указатель на саму себя. неверная.
}

#include <iostream>
#include <functional>
 
struct button
{
 
    typedef std::function<void()>
        callback;
    
    
    callback onPressed;
    
    
    void simulatePressed()
    {
        if(onPressed)
            onPressed();
    }
};
 
 
void if_pressed()
{
    std::cout<<"на кнопку нажали\n"; 
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    button b;
    b.onPressed = if_pressed;
    
    
    b.simulatePressed();
}

#include <iostream>
 
 
// --- будем запускать её
int foo() { std::cout<< __PRETTY_FUNCTION__ << std::endl; return 0; }
 
 
// --- общий шаблон - не функционирует
// попытка вызвать его для абы какого T будет приводить
// к ошибкам компиляции
template<class T>struct delegate;
 
    
// --- специализация для случая, когда делегат
// это функция    
template<class R, class... Args>
struct delegate<R(Args...)>
{
    // из шаблона выводится тип функции
    // которую нужно запустить.
    typedef R(*pFunc)(Args...);
    
    
    // --- нацеливание делегата в конструкторе
    delegate( R foo(Args...)  )
        :mFunc(foo) 
    {} 
    
    R operator ()(Args&&... args)
    {
        // -- запуск функции
        return  mFunc( std::forward<Args>(args)...  );
    }
    
    pFunc mFunc;
};
 
 
int main()
{
    std::cout << "Hello, world!\n";
 
    
    // --- создаем делегат,
    // который нацелен на запуск функции foo
    delegate<int()> d = foo;
    
    // запускаем функцию foo опосредованно,
    // через делегат
    d();
}

#include <iostream>
 
void f (void (*_f)(void*)) {
  static int n= 2;
  std::cout << n << std::endl;
  if (--n) _f ((void*)f);
}
 
int main() {
  void (*pf)(void(*)(void*))= f;
  pf ((void(*)(void*))f);
}