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

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

#include <iostream>
#include <functional>
 
void foo(const struct myself& f, const size_t depth);
 
struct myself
{
    template<class T> myself(T&& v)
        :mCaller( std::bind(foo, foo, std::placeholders::_1) )
    {}
    
    void operator()(const size_t depth)const 
        { mCaller(depth); }
    
    std::function<void(const size_t)> 
        mCaller;
};
 
void foo(const myself& f, const size_t depth)
{
    if(depth == 0)
        return;
    
    std::cout<<"depth recursieve: "<< depth << '\n';
    f(depth - 1);
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    foo(foo, 10);
}

#include <iostream>
#include <functional>
 
class recursivePointer
{
    typedef std::function<void(const size_t)> 
        functor;
public:
    template<class T> recursivePointer(T&& v)
        :mCaller( std::bind(v, v, std::placeholders::_1) )
    {}
    
    recursivePointer(const functor& v)
        :mCaller(v)
    {}
    recursivePointer(functor&& v)
        :mCaller( std::move(v) )
    {}
    
    void operator()(const size_t depth)const 
        { mCaller(depth); }
    
    operator const functor&()const
        { return mCaller; }
    
private:    
    functor mCaller;
};
 
void foo(const recursivePointer& f, const size_t depth)
{
    if(depth == 0)
        return;
    
    std::cout<<"depth recursieve: "<< depth << '\n';
    f(depth - 1);
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    const auto pFunc = recursivePointer(&foo);
    
    foo(pFunc, 10);
    std::cout<< "--------------\n";
    
    foo(foo, 10);
    std::cout<< "--------------\n";
    
    foo(&foo, 10);
    std::cout<< "--------------\n";
}

foo1(*ptr){}; //Внутри указатель
foo2(*ptr){}; //Внутри указатель
...
*ptr = foo1(ptr);  //Сделали указатель на foo1 и отдали его вовнутрь ;
**ptr; //Подобие разыменования вызывает функцию foo1, а вовнутрь отдается ptr.
 
*ptr = foo2(ptr); //Сделали указатель на foo2 и отдали его вовнутрь;
**ptr; //Подобие разыменования вызывает foo2, а вовнутрь отдается ptr.

const auto pFunc = recursivePointer(&foo);

foo(pFunc,
foo(foo,
foo(&foo

**ptr; //Обычным разыменованием указателя Вызвал функцию. Если внутри нее разыменовать ptr, то рекурсия
ptr = foo2; //Указатель указывает на другую функцию
**ptr; //Вызвал функцию. Если внутри нее разыменовать ptr, то рекурсия, но уже вот текущей функции

// во внутрь foo попадает объект, 
// который является указателем на функцию foo
foo(&foo, 10);

// --- срисовали
const auto pFunc = recursivePointer(&foo);
 
// чуть позде можно будет запускать:
foo(pFunc, 10);

// --- принимает рекурсивный указатель на саму себя
void foo(const recursivePointer& f, const size_t depth)
{
    if(depth == 0)
        return;
    
    std::cout<<"depth recursieve: "<< depth << '\n';
 
    // --- дергает саму себя по указателю
    f(depth - 1);
}

void foo(const recursivePointer& f, const size_t depth)
{
    if(depth == 0)
        return;
    
    std::cout<<"depth recursieve: "<< depth << '\n';
 
    // --- вызвать саму себя, передав явный дополнительный аргумент
    f(depth - 1);
}

const auto pFunc = recursivePointer(&foo);