What are the advantages of using functions to modularize a program?

Answer 1

Advantages of functions:

1. Program development made easy : Work can be divided among project members thus implementation can be completed in parallel.
2. Program testing becomes easy : Easy to locate and isolate a faulty function for further investigation
3. Code sharing becomes possible : A function may be used later by many other programs this means that a c programmer can use function written by others, instead of starting over from scratch.
4. Code re-usability increases : A function can be used to keep away from rewriting the same block of codes which we are going use two or more locations in a program. This is especially useful if the code involved is long or complicated.
5. Increases program readability : It makes possible top down modular programming. In this style of programming, the high level logic of the overall problem is solved first while the details of each lower level functions is addressed later. The length of the source program can be reduced by using functions at appropriate places.
6. Function facilitates procedural abstraction : Once a function is written, it serves as a black box. All that a programmer would have to know to invoke a function would be to know its name, and the parameters that it expects
7. Functions facilitate the factoring of code : Every C program consists of one main( ) function typically invoking other functions, each having a well-defined functionality.

Answer 2

Function templates are advantageous whenever you wish to overload a function where the implementation is exactly the same regardless of the type of data it processes. That is, the only difference between each overload is in the type of arguments it accepts. So rather than writing separate functions for each type, you simply declare one function, and let the compiler generate the specific overloads for you. This reduces code maintenance, because all overloads can be modified through a single function, rather than several functions.

By way of an example, if you wished to find the largest of two values, you could write the following functions:

int max(int x, int y){ return(x>y?x:y); }

float max(float x, float y){ return(x>y?x:y); }

char max(char x, char y){ return(x>y?x:y); }

You could continue in this fashion, providing a wide variety of overloads to cater for both primitives and user-defined types. However, in each case the implementation is exactly the same but you'd also be forced to write additional overloads whenever no suitable overload existed.

Function templates simplify everything by getting the compiler to do all the work for you from a single function:

template<class T>

T& max(T& x, T& y){ return(x>y?x:y); }

Now when you want the max of any type, you simply call the max() function, passing the types as arguments. The only criteria is that both types must be of the same type, and the type must support the greater-than operator. Note that the types are also passed by reference rather than by value (as they were in the original declarations). This assures that all user-defined objects, regardless of their complexity, can be compared without invoking their copy constructors.

The only disadvantage is that you cannot call max() with mixed types. Instead, you must cast the mixed types to a common type, which may not always be possible when working with user-defined types.

Answer 3

function is useful when u create a huge project .

you can separate the program in different parts and combine it.

and this splitting up of programs into sets of instructions increases the flexibility of the program.

Answer 4

A C program cannot run without functions.