Можно ли в C++ определить функцию, которая возвращает указатель на функцию с той же сигнатурой?

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

typedef int (*foo_type)();
typedef foo_type (*foo_type1)();
typedef foo_type1 (*foo_type2)();
 
int q()
{
    return 3;
}
 
foo_type foo()
{
    return &q;
}
 
foo_type1 foo1()
{
    return &foo;
}
 
foo_type2 foo2()
{
    return &foo1;
}
 
int main()
{ 
    int result = (* (* (* (*foo2)() )() )() )() ;
}

typedef void *foo_type();
 
foo_type *foo()
{
    return reinterpret_cast<foo_type *>( &foo );
}
 
int main()
{ 
    foo_type *p = foo();
 
    for(int i = 0; i < 10; i++)
        p = reinterpret_cast<foo_type *>((*p)());
}

#include <iostream>
 
typedef void *(*foo_type)(int level);
 
foo_type foo(int level)
{
    std::cout << level << std::endl;
    return reinterpret_cast<foo_type>( &foo );
}
 
int main()
{ 
    foo_type p = foo(0);
 
    for(int i = 1; i < 10; i++)
        p = reinterpret_cast<foo_type>((*p)(i));
}

auto func() -> void*
{
    return &func;
}

typedef auto (*pfunc)() -> auto (*)() -> pfunc;
 
pfunc func()
{
    return &func;
}

typedef auto (*pfunc)() -> pfunc;

typedef auto (*pfunc)() -> void *;
 
pfunc funct()
{
    return reinterpret_cast<pfunc>(&funct);
}
 
int main()
{
    pfunc p_f = funct();
    p_f = reinterpret_cast<pfunc>((*p_f)());
}

funct()()()()()

typedef auto (*pfunc)() -> void *;
// либо так:
// typedef void *(*pfunc)();
 
void *funct()
{
    return reinterpret_cast<void *>(&funct);
}
 
int main()
{
    pfunc p_f = reinterpret_cast<pfunc>(funct());
    p_f = reinterpret_cast<pfunc>((*p_f)());
    p_f = reinterpret_cast<pfunc>((*p_f)());
}

fumct()()()();