Is it good to use functions as much as possible?

When I read open source codes (Linux C codes), I see a lot functions are used instead of performing all operations on the main(), for example:

int main(void ){
    function1();
    return 0;
}

void function() {
    // do something
    function2();
}

void function2(){
    function3();
    //do something
    function4();
}

void function3(){
    //do something
}
void function4(){
    //do something
}

Could you tell me what are the pros and cons of using functions as much as possible?

• easy to add/remove functions (or new operations)
• readability of the code
• source efficiency(?) as the variables in the functions will be destroyed (unless dynamic allocation is done)
• would the nested function slow the code flow?

• Easy to add/remove functions (or new operations)

Definitely - it's also easy to see where does the context for an operation start/finish. It's much easier to see that way than by some arbitrary range of lines in the source.

• Readability of the code

You can overdo it. There are cases where having a function or not having it does not make a difference in linecount, but does in readability - and it depends on a person whether it's positive or not.

For example, if you did lots of set-bit operations, would you make:

some_variable = some_variable | (1 << bit_position)

a function? Would it help?

• Source efficiency(?) due to the variables in the functions being destroyed (unless dynamic allocation is done)

If the source is reasonable (as in, you're not reusing variable names past their real context), then it shouldn't matter. Compiler should know exactly where the value usage stops and where it can be ignored / destroyed.

• Would the nested function slow the code flow?

In some cases where address aliasing cannot be properly determined it could. But it shouldn't matter in practice in most programs. By the time it starts to matter, you're probably going to be going through your application with a profiler and spotting problematic hotspots anyway.

Compilers are quite good these days at inlining functions though. You can trust them to do at least a decent job at getting rid of all cases where calling overhead is comparable to function length itself. (and many other cases)