Well, it is confusing a bit.

Function type and pointer to function type are indeed two different types (no more similar than int and pointer to int). However, there is a rule, that a function type decays to pointer to function type in almost all contexts. Here decaying loosely means converted (there is a difference between type conversion and decaying, but you are probably not interested in it right now).

What is important, is that almost every time you use a function type, you end up with pointer to function type. Note the almost, however – almost every time is not always!

And you are hitting some cases when it doesn’t.

typedef void(functionPtr)(int);
functionPtr fun = function;

This code attempts to copy one function (not the pointer! the function!) to another. But of course, this is not possible – you can’t copy functions in C++. The compiler doesn’t allow this, and I can’t believe you got it compiled (you are saying you got linker errors?)

Now, this code:

typedef void(functionPtr)(int);
functionPtr function;
function(5);

function does not shadow anything. Compiler knows it is not a function pointer which can be called, and just calls your original function.

The most interesting of your examples is this one, reproduced here without the use of typedef:

void function(int a) { // declaration and definition of 'function'
    std::cout << a << std::endl;
}

int main() {
    void function(int); // declaration of 'function'
    function(5);
}

In most contexts in C++, the re-declaration of function in local scope would shadow the global ::function. So expecting a linker-error there makes sense – main()::function has no definition right?

Except functions are special in this regard. From a note in [basic.scope.pdel]:

Function declarations at block scope
and variable declarations with the extern specifier at block scope refer to declarations that are members of
an enclosing namespace, but they do not introduce new names into that scope.

So that code example is exactly equivalent to:

void function(int a) { /* ... */ }
void function(int ); // just redeclaring it again, which is ok

int main() {
    function(5);
}

You can also verify this by putting the global function into some namespace, N. At this point, the local scope declaration would add a name to ::, but it wouldn’t have a definition – hence you do get a linker error.

The other interesting thing you touched on is the notion of function-to-pointer conversion, [conv.func]:

An lvalue of function type T can be converted to a prvalue of type “pointer to T”. The result is a pointer to
the function.

When you have a function call expression – if the thing you’re calling is a function type, it is first converted to a pointer-to-function. That’s why these are equivalent:

fun(5);         // OK, call function pointed to by 'fun'
(*fun)(5);      // OK, first convert *fun back to 'fun'
function(5);    // OK, first convert to pointer to 'function'
(*function)(5); // OK, unary* makes function get converted to a pointer
                // which then gets dereferenced back to function-type
                // which then gets converted back to a pointer

Let’s see your examples one by one, and what they really mean.

typedef void(functionPtr)(int);

void function(int a){
    std::cout << a << std::endl;
}

int main() {

    functionPtr fun = function;
    fun(5);

    return 0;
}

Here you are creating a typedef functionPtr for functions which take and int, and don’t return values. functionPtr is not actually a typedef for a function pointer, but of an actual function.

Then you are trying to declare a new function fun, and assign to it function. Unfortunately you cannot assign to functions, so this does not work.

int main() {

    functionPtr fun;
    fun(5);

    return 0;
}

Again, you are declaring a function fun with the signature you specified. But you don’t define it, so rightfully you fail the linking phase.

typedef void(functionPtr)(int);

void function(int a){
    std::cout << a << std::endl;
}

int main() {

    functionPtr function;
    function(5);

    return 0;
}

What happens here? You define the typedef, and in the main you write functionPtr function;. This basically is simply a prototype for the function you have already written, function. It restates that this function exists, but otherwise it does nothing. In fact, you can write:

typedef void(functionPtr)(int);

void function(int a){
    std::cout << a << std::endl;
}

int main() {

    functionPtr function;
    functionPtr function;
    functionPtr function;
    void function(int);

    function(5);

    return 0;
}

How many times you want, it won’t change a thing. The function(5) you are calling after is always the same thing.

One thing you can do in C++ is to declare the prototype of a function using such a typedef, but you cannot define it in that way.

typedef void(*functionPtr)(int);

functionPtr function(int a){
    std::cout << a << std::endl;
}

Here you are defining a function which returns a function pointer, but then you do not return it. The compiler, depending on your settings, may or may not complain. But again function is completely separated from functionPtr. You have essentially written

void (*)(int)   function(int a) {
    ...
}

The last example, the one where you have a function returning a function, is simply not allowed, because it would be meaningless.

typedef void functionPtr (int);

void function (int a){
    std::cout << a << std::endl;
}

int main() {

    functionPtr *func;
    func = function;
    func(5);
    return 0;
}

You can use it in this way, I had tested.
There really a litter tricky about this issue.