well, In this C programming tutorial, we are going to learn how to create user defined functions containing code statements designed to fulfil a specific task. If the reader has not yet set up their environment using the Borland C compiler (or equivalent) they should refer to the Setting up C article before reading the rest of this tutorial.
A function is a user defined piece of code that should encapsulate a single task. Frequently, there is the temptation to cover many different processes within a single function, but this is considered bad style. Instead, try to break down a task into several pieces, and link them together, with each piece in a separate function.

The key to using functions is to imagine that a reader might wish to read ten lines of code, and understand what the design of the program is, but that these ten lines might represent hundreds of lines of code that the reader does not need to look at.

For example, we might see a line of code that says:

DisplayMenuOptions();

W e know that the outcome will be to display the menu options on the screen, and that to do this, many lines of code must be evaluated. However, from the single function call, we can infer that behavior without having to skip over it when looking for a specific piece of code, not related to menu options.

Were this not in a function, then we would be obliged to read through all the menu display code before finding the one nugget we are interested in. This would quickly become tedious.

The other aspect of programming using functions is known as re-use. The re-use mechanism allows us to define functions which can be used in several places in the code.
source site: http://computerprogramming.suite101 .com/article.cfm/functions_and_para meters_in_c

Answered by Nidhi Singh , an ibibo Master, at 10:42 AM on September 29, 2008

well, inline functions long before standard C introduced them (in the 1999 standard); this page summarizes the rules they use, and makes some suggestions as to how to actually use inline functions.

The point of making a function "inline" is to hint to the compiler that it is worth making some form of extra effort to call the function faster than it would otherwise - generally by substituting the code of the function into its caller. As well as eliminating the need for a call and return sequence, it might allow the compiler to perform certain optimizations between the bodies of both functions.

Sometimes it is necessary for the compiler to emit a stand-alone copy of the object code for a function even though it is an inline function - for instance if it is necessary to take the address of the function, or if it can't be inlined in some particular context, or (perhaps) if optimization has been turned off. (And of course, if you use a compiler that doesn't understand "inline", you'll need a stand-alone copy of the object code so that all the calls actually work at all.)
source site: http://www.greenend.org.uk/rjk/2003 /03/inline.html

Answered by Romi , an ibibo Master, at 4:36 PM on September 26, 2008

There are two types of functions. The ones that are provided with the compiler and the ones that you write. Let's look at the functions provided with the compiler.

Built In Functions
Ansi C specifies 15 include files that compiler writers must implement for the C standard library. They are listed below.

* <assert.h> *Diagnostics
* <ctype.h> *Character Class Tests
* <errno.h> Error Codes Reported by Library Functions
* <float.h> Floating-Point Limits
* <limits.h> Implementation-defined Limits
* <locale.h> Locale-specific Information
* <math.h> *Mathematical Functions
* <setjmp.h> Non-local Jumps
* <signal.h> Signals
* <stdarg.h> *Variable Argument Lists
* <stddef.h> Definitions of General Use
* <stdio.h> *Input and Output
* <stdlib.h> *Utility functions
* <string.h> *String functions
* <time.h> *Time and Date functions
* Are the ones I consider most useful.

On the next Page : Learn how to call functions.

Index: C Tutorial - Lesson Six - About Functions

1. Learn About Functions
2. Calling a Function and Writing Your Own Functions
3. Function Parameters
4. Learn about Function Prototypes
5. Learn more about how to write and use variadic functions.
6. Learn how the variadic function total works

For more visit :

http://cplus.about.com/od /learningc/ss/clessonsix.htm

Answered by Ashish Yadav , an ibibo Wizard, at 8:19 AM on September 22, 2008

function declaration - this provides the information needed to call a function. the declaration gives the name of the function, its return type and the type of each argument

Answered by Nishu's , an ibibo Master, at 1:18 PM on September 20, 2008

Almost all programming languages have some equivalent of the function. You may have met them under the alternative names subroutine or procedure.
Some languages distinguish between functions which return variables and those which don't. C assumes that every function will return a value. If the programmer wants a return value, this is achieved using the return statement. If no return value is required, none should be used when calling the function.
Here is a function which raises a double to the power of an unsigned, and returns the result.
double power(double val, unsigned pow)
{ double ret_val = 1.0;
unsigned i;

for(i = 0; i < pow; i++)
ret_val *= val;

return(ret_val);
}
The function follows a simple algorithm, multiplying the value by itself pow times. A for loop is used to control the number of multiplications, and variable ret_val stores the value to be returned. Careful programming has ensured that the boundary condition is correct too. ie .
Let us examine the details of this function.
double power(double val, unsigned pow)
This line begins the function definition. It tells us the type of the return value, the name of the function, and a list of arguments used by the function. The arguments and their types are enclosed in brackets, each pair separated by commas.
The body of the function is bounded by a set of curly brackets. Any variables declared here will be treated as local unless specifically declared as static or extern types.
return(ret_val);
On reaching a return statement, control of the program returns to the calling function. The bracketed value is the value which is returned from the function. If the final closing curly bracket is reached before any return value, then the function will return automatically, any return value will then be meaningless.
The example function can be called by a line in another function which looks like this
result = power(val, pow);
This calls the function power assigning the return value to variable result.
Here is an example of a function which does not return a value.
void error_line(int line)
{ fprintf(stderr, "Error in input data: line %d\n", line);
}
The definition uses type void which is optional. It shows that no return value is used. Otherwise the function is much the same as the previous example, except that there is no return statement. Some void type functions might use return, but only to force an early exit from the function, and not to return any value. This is rather like using break to jump out of a loop.

Answered by ayisha , an ibibo Master, at 11:04 PM on September 19, 2008

A function is a section of code that has some separate functionality or does something that will be done over and over again.

As a basic example, you are writing code to print out the first 5 squares of numbers, then the first 5 cubes, then the next 5 squares again. We could write it like this:

for(i=1; i <= 5; i++)
{
printf("%d ", i*i);
}
for(i=1; i <= 5; i++)
{
printf("%d ", i*i*i);
}
for(i=1; i <= 5; i++)
{
printf("%d ", i*i);
}

Answered by akash singh , an ibibo Citizen, at 8:13 PM on September 19, 2008

In C language (and other similar programming languages) , a 'function' is a named procedure or routine that performs a distinct service. The language statement that requests the function is called a function call. C assumes that every function will return a value like printing on screen or calculating equations. If the programmer wants a return value, this is achieved using the return statement. If no return value is required, none should be used when calling the function. Programming languages usually come with a compiler and a set of "canned" functions that a programmer can specify by writing language statements. These provided functions are sometimes referred to as library routines . Some functions are self-sufficient and can return results to the requesting program without help. Other functions need to make requests of the operating system in order to perform their work. You can also write your own functions to perform specialized tasks.

Answered by A.R. , an ibibo Master, at 6:58 PM on September 19, 2008

A function is a section of code that has some separate functionality or does something that will be done over and over again.

As a basic example, you are writing code to print out the first 5 squares of numbers, then the first 5 cubes, then the next 5 squares again. We could write it like this:

for(i=1; i <= 5; i++)
{
printf("%d ", i*i);
}
for(i=1; i <= 5; i++)
{
printf("%d ", i*i*i);
}
for(i=1; i <= 5; i++)
{
printf("%d ", i*i);
}


We have to write the same loop twice. We may want to somehow put this code in a separate place and simply jump to this code when we want to use it.

This is what precisely functions are for.

A function is like a black box. It takes in input, does something with it, then spits out an answer.

Note that a function may not take any inputs at all, or it may not return anything at all. In the above example, if we were to make a function of that loop, we may not need any inputs, and we aren't returning anything at all (Text output doesn't count - when we speak of returning we mean to say meaningful data that the program can use).

We have some terminology to refer to functions:

* A function, call it f, that uses another function g, is said to call g. For example, f calls g to print the squares of ten numbers.
* A function's inputs are known as its arguments
* A function that wants to give f back some data that g calculated is said to return that data. For example, g returns the sum of its arguments.

int square(int x)
{
int square_of_x;
square_of_x = x * x;
return square_of_x;
}

To understand how to write such a function like this, it may help to look at what this function does as a whole. It takes in an int, x, and squares it, storing it in the variable square_of_x. Now this value is returned.

The first int at the beginning of the function declaration is the type of data that the function returns. In this case when we square an integer we get an integer, and we are returning this integer, and so we write int as the return type.

Next is the name of the function. It is good practice to use meaningful and descriptive names for functions you may write. It may help to name the function after what it is written to do. In this case we name the function "square", because that's what it does - it squares a number.

Next is the function's first and only argument, an int, which will be referred to in the function as x. This is the function's input.

In between the braces is the actual guts of the function. It declares an integer variable called square_of_x that will be used to hold the value of the square of x. Note that the variable square_of_x can only be used within this function, and not outside. We'll learn more about this sort of thing later, and we will see that this property is very useful.

We then assign x multiplied by x, or x squared, to the variable square_of_x, which is what this function is all about. Following this is a return statement. We want to return the value of the square of x, so we must say that this function returns the contents of the variable square_of_x.

Answered by Nagendra , an ibibo Master, at 6:34 PM on September 19, 2008

Kokila In a computer program, set of instructions, given a particular name, that will be executed when the main program calls for it. In BASIC, a function is labeled by the number of its first line and is executed when a GOSUB command is reached. The command RETURN marks the end of the subroutine and tells the computer to return to the main program.

Answered by Keshto Patel , an ibibo Master, at 6:25 PM on September 19, 2008

Almost all programming languages have some equivalent of the function. You may have met them under the alternative names subroutine or procedure.

Some languages distinguish between functions which return variables and those which don't. C assumes that every function will return a value. If the programmer wants a return value, this is achieved using the return statement. If no return value is required, none should be used when calling the function.

Here is a function which raises a double to the power of an unsigned, and returns the result.


double power(double val, unsigned pow)
{ double ret_val = 1.0;
unsigned i;

for(i = 0; i < pow; i++)
ret_val *= val;

return(ret_val);
}

The function follows a simple algorithm, multiplying the value by itself pow times. A for loop is used to control the number of multiplications, and variable ret_val stores the value to be returned. Careful programming has ensured that the boundary condition is correct too. ie .

A function in C can perform a particular task, and supports the concept of modular programming design techniques.

We have already been exposed to functions. The main body of a C program, identified by the keyword main, and enclosed by the left and right braces is a function. It is called by the operating system when the program is loaded, and when terminated, returns to the operating system.

Functions have a basic structure. Their format is:

return_ data_type function name (arguments, arguments)
data _type _declarations of arguments;
{

function body

}

It is worth noting that a return data type is assumed to be of type int unless otherwise specified, thus programs we have seen so far imply that main() returns an integer to the operating system. ANSI C varies slightly in the way that functions are declared. Its format is:

return_data_type function name (data type variable name, data type variable name,….)
{

function body

}

This permits type checking by utilizing function prototypes to inform the compiler of the type and number of parameters a function accepts. When calling a function, this information is used to perform the type and parameter checking.

ANSI C also requires that the return_ data_type for a function which does not return data must my of type void. The default return_ data_type is assumed to be an integer unless otherwise specified, but must match that which the function declaration specifies. A simple function is:

int print_message ()
{

printf(“This is a module called print_message.\n”);

}

Note the function name is print_message. No arguments are accepted by the function, this is indicated by the keyword void in accepted parameter section of function declaration. The return_data_type is void, this data is not returned by the function. An ANSI C function prototype for print_message() is:

int print_message ();

Function prototypes are listed at the beginning of the source file. Often, they might be placed in a users .h (header) file.

Answered by NEVIDITA , an ibibo Master, at 6:06 PM on September 19, 2008