Define function with advantages and disadvantages in C programming?

Answer 1

Answering :"Less code,more work" shows the performance/standard of the program.ADVANTAGES:*It reduces the Complexity in a program by reducing the code.*It also reduces the Time to run a program.In other way,Its directly proportional to Complexity.*Its easy to find-out the errors due to the blocks made as function definition outside the main function.DISADVANTAGES:

Answer 2

The advantage of a function is that the function code is all in one place and can be called as often as is required. You don''t have to write the same section of code over and over, you simply call the function containing the code, thus ensuring your code is consistent. If you need to change the implementation of the function, you only need to make those changes in one place, rather than throughout your code, which could lead to errors if you fail to propogate your changes correctly.

The disadvantage of a function is that it incurs a function call. What this means is that whenever you call a function, the state of the calling function's local variables must be pushed onto the stack, along with the return address (the instruction following the function call) and the called function's arguments. Control is then passed to the called function which will then pop the arguments from the stack and begin processing. The function may call other functions, incurring the same penalty. However, the return addresses remain on the stack until a function is ready to return, at which point the return address is popped from the stack and control passed back to that address. This mechanism is not unlike leaving a trail of breadcrumbs that allow functions to return to their callers, and is also known as "function unwinding". However, with so much going on in the background, function calls are expensive in terms of performance. Functions that call other functions can also be expensive in terms of memory consumption, especially when passing objects to function by value (which automatically invokes the object's copy constructor) rather than by reference (which simply passes a reference to the object itself).

However, you can still retain the advantage of having a function but also eliminate the disadvantage of making a function call by declaring the function as a candidate for inline expansion. If the function is only called from one place (even within a loop), then the compiler will expand the function inline, just as if you'd manually expanded the function manually. In these cases the need for a function is not essential, but function calls can greatly simplify more complex functions. So rather than having one large and complex function, you might break it down into a series of simpler functions calls, each of which could be inline expanded, thus achieving maximum performance but simplifying your actual code, making it easier to read and maintain.

Even complex functions that are seldom called may be inline expanded, as can simple functions that are called many times throughout your code, provided the increased code size would not itself be detrimental to performance. It should be noted that declaring a function as a candidate for inline expansion is no guarantee the function will actually be inline expanded; that aspect is decided by the compiler's optimisers. But if a function call makes your code easier to read and maintain, then the cost of a function call is usually a small price to pay to achieve less code, and will cost nothing at all if the call can be inline expanded.

The best approach is to keep all your functions as simple as possible, thus increasing the chances of them being inline expanded. There will be some exceptions, of course (especially deeply-nested recursive calls), but ultimately you want to achieve the greatest performance for the smallest code size. The larger the code size, the greater the cost in performance, so a few function calls are inevitable, but any loss incurred by them is usually more than outweighed by the smaller overall code size.

Answer 3

Functions allow you to reuse code without having to copy and paste the same code in multiple sections of your program. This allows you to save time and also makes your program more efficient.