Share Knowledge and Skills

Saturday, 4 October 2014

C Programming - Functions

11:47 Posted by Unknown No comments
Learning C/C++ Step-By-Step - Page 06
.
06. Step-by-Step C/C++ --- C Programming - Functions
Functions
     I. Introduction
     II. Function definition
     III. Types of functions
     IV. Built-in functions
          1. Numeric functions
     2. String functions
     3. Character Test Functions
     V. User-Defined functions
          1. Simple Functions
     2. Function with Arguments
     3. Function with Returns
     4. Function with Recursion
     VI. Pointers and Functions
          1. Parameter Passing by Reference
     2. Call by value
     3. Call by Reference
     VII. Local Vs Global
     VIII. Storage Class Specifiers
           Automatic Storage Class
      Register Storage Class
      Static Storage Class
      External Storage Class

I. Introduction
Here is a program to print the address of a person twice, which is written in both methods using functions and without using functions. It will demonstrate the advantage of functions.
     #include <stdio.h>
int main()
{
     printf("\nName of the Person");
     printf("\nStreet, Apartment//House No. ");
     printf("\nzip, City");
     printf("\nCountry");

     printf("\nName of the Person");
     printf("\nStreet, Apartment//House No. ");
     printf("\nzip, City");
     printf("\nCountry");

     return 0;
}    #include <stdio.h>
void address()
{
     printf("\nName of the Person");
     printf("\nStreet, Apartment//House No. ");
     printf("\nzip, City");
     printf("\nCountry");
}

int main()
{
     address();
     address();

     return 0;
}

II. Function Definition
A statement block, which has ability to accept values as arguments and return results to the calling program. So, A function is a self-contained block of statements that perform a specific task.

III. Types of functions
     - Built-in functions/ Library Functions/ Pre-Defined functions
- User defined functions

IV. Library Functions
Library functions are designed by the manufacturer of the software, They were loaded in to the disk whenever the software is loaded.
The following functions are the example of the library functions.


1. Numeric Functions
Function    Syntax    Eg.    Result
Abs    Abs(n)    abs(-35)    35
ceil    ceil(n)    ceil(45.232)    46
floor    floor(n)    floor(45.232)    45
fmod    fmod(n,m)    fmod(5,2)    1
cos    cos(n)    cos(60)    0.5
sin    sin(n)    sin(60)     0.866
tan    tan(n)    tan(60)    1.732
sqrt    sqrt(n)    sqrt(25)    5
pow    pow(n,m)    pow(2,3)    8
2. String Functions
Functions       Syntax    Eg.
strlen      strlen(str)    strlen(“Computer”)
strcpy      strcpy(target,source)    strcpy(res,”Pass”)
strcat       strcat(target,source)    strcat(“mag”,”gic”)
strcmp     strcmp(str1,str2)     strcmp(“abc”,”Abc”)
strrev       strrev(target,scr)    fstrrev(res,”LIRIL”)
3. Character Test Functions
Function    Description
isalnum    is a letter or digit
isalpha    is a letter
isdigit    is a digit
iscntrl    is an ordinary control character
isascii    is a valid ASCII character
islower    is a lower character
isupper    is a upper character
isspace    is a space character
isxdigit    is hexa decimal character
There is a huge library of functions available, I have given you a tiny portion of it. For more Library Fuctions refer the Help Manual.

V. User-Defined Functions
The programs you have already seen perform divisions of labor. When you call gets, puts, or strcmp, you don’t have to worry about how the innards of these functions work.
These and about 400 other functions are already defined and compiled for you in the Turbo C library. To use them, you need only include the appropriate header file in your program, “The run-time library,” in the library reference to make sure you understand how to call the functions, and what value (if any) it returns.
But you’ll need to write your own functions. To do so, you need to break your code into discrete sections (functions) that each perform a single, understandable task for your functions, you can call them throughout your program in the same way that you call C library functions.
Steps to implement a function
     1. Declaration
2. Function Call
3. Definition

     • Every function must be declared at the beginning of the program.
• Function definition contains the actual code of execution task.
• If a function is defined at the beginning of the program, there is no need of function declaration.

An example function to demonstrate the implementation
     /* 32_egfun.c */
#include <stdio.h>

void address();      /* Declaration */

int main()
{
     address();      /* Function Call */
     address();      /* Function Call */

     return 0;
}

void address()      /* Definition */
{
     printf("\nName of the Person");
     printf("\nStreet, Apartment//House No. ");
     printf("\nzip, City");
     printf("\nCountry");
}
User defined functions can be divided in to 4 types based on how we are calling them.
     1. Simple Functions
2. Function with Arguments
3. Function with Returns
4. Function with Recursion

1. Simple Functions
     Performs a specific task only, no need of arguments as well as return values
Example of Simple Function
     /* 33_line.c */
#include <stdio.h>
void line();      /* Declaration */
int main()
{
     line();      /* Function call */
     return 0;
}
void line()      /* Definition */
{
     int i;
     for(i =1;i<80; i++)
          putch(‘*’);
}
2. Function with Arguments
     A function, which accepts arguments, is known as function with arguments.
Eg.
     /* 34_argu.c */
void line(char ch, int n)
int main()
{
     line("-", 50);
     line("*", 8);
     return 0;
}
void line(char ch, int n)
{
     int i;
     for( i = 1; i<=n; i++ )
          putch(ch);
}
3. Function with Return values
     A function which can return values to the calling program is known as function with return values.
Eg.
     /* 35_retu.c */
int abs(int n);
int main()
{
     int res;
     printf(“%d”, abs(-35))

     res = abs(-34);     /* Function Call*/

     printf(“%d”, res);
     return 0;
}
void abs(int n)
{
     if( n < 0 )
     n = n * -1;
     return n;
}
4. Function with Recursion
If a statement within the body of a function call the same function is called ‘recursion’ . Sometimes called ‘circular definition’, recursion is thus the process of defining something in terms of itself.
Examples of Recursive of functions
     /* The following program demonstrates function call of itself */
int main( )
{
     printf(“\nHello”);
     main( ); /* A function, which can call it self */
     return 0;
}
Don’t run this program, it is still an explanation thus program is not valid logically.

The same output can be reached using another function:
void disp( );

int main( )
{
     disp( );
     return 0;
}

void disp( )
{
     printf(“\nHello”);
     disp( );
}
The program must end at a certain point so the key of the recursion lies on soft interrupt, which can be defined using a conditional statement.
Check the following example:
     /* 36_recursion.c */
int i = 1;      /* Declaring a global variable */
void disp( );
int main( )
{
     disp( );
     return 0;
}

void disp( )
{
     printf(“\nHello %d ”, i);
     i ++;
     if( i < 10 ) /* if i value is less than 10 then call the function again */
          disp( );
}
     Program to find the factorial of the given number:
/* 37_fact.c */
int factorial(int x);
void main
{
     int a, fact;
     printf("\nEnter any number "); scanf("%d", &a);
     fact = factorial(a);
     printf("\nFactorial is = %d", fact);
}
int factorial(int x)
{
     int f = 1, i;
     for( i = x; i>=1; i--)
     f = f * i;
     return f;
}    To find the factorial of a given number using recursion
/* 38_fact.c */
int rec_fact(int x);
int main( )
{
     int a, fact;
     printf("\nEnter any number "); canf("%d", &a);
     fact = rec_fact(a);
     printf("\nFactorial value is = %d", fact);
     return 0;
}
int f = 1;
int rec_fact(int x)
{
     if( x > 1)
          f = x * rec_fact(x-1);
     return f;
}

VI. Pointers and Functions
     Parameter Passing by Reference
Call by value
Call by Reference
1. Parameter Passing by Reference
The pointer ca n be used in function declaration and this makes a complex function to be easily represented as well as accessed. The function definition makes use of pointers in it, in two ways
     – Call by value
- Call by reference
The call by reference mechanism is fast compared to call by value mechanism because in call by reference, the address is passed and the manipulation with the addresses is faster than the ordinary variables. More ever, only one memory location is created for each of the actual parameter.
When a portion of the program, the actual arguments, calls a function and the values altered within the function will be returned to the calling portion of the program in the altered form. This is termed as call by reference or call by address. The use of pointer as a function argument in this mechanism enables the data objects to be altered globally ie within the function as well as within the calling portion of the program. When a pointer is passed to the function, the address of the argument is passed to the functions and the contents of this address are accessed globally. The changes made to the formal parameters (parameters used in function) affect the original value of the actual parameters (parameters used in function call in the calling program).
Eg.
     /* 39_func.c */

void func_c( int *x );

int main()
{
     int i = 100;
     int *a;
     a = &i;
     printf("\nThe value is %d", i);
     func_c(a);
     printf("\nThe value is %d", i);
     return 0;
}

void func_c( int *x )
{
     (*x) ++;
     printf("\nThe value in function is %d ", *x);
}
In the above program, these are totally three ‘printf’ statements, tow in the main() function and one in the function subprogram. Due the effect of first printf statement the value of i is printed as 100. Later function call is made and inside function, the value is altered in and is 1001 due to increment. The altered value is again returned to main() and is printed as 1001.
Hence the output is:
     The value is 100
The value in function is 101
The value is 101
More about Function Calls
Having had the first tryst with pointers let us now get back to what we had originally set out to learn – the two types of functions calls: call by value and call by reference. Arguments can generally be passed to function in one of the two ways:
     a. Sending the values of the arguments
b. Sending the addresses of the arguments
2. Call by Value
In the first method the ‘value’ of each of the actual arguments in the calling function is copied into corresponding formal arguments of the called function. With this method the changes made to the formal arguments in the called function have no effect on the values of actual arguments in the calling function. The following programming illustrated the Call by Value.
     /* 40_callbyvalue.c */
void swap( int x, int y )
int main( )
{
     int a = 10, b = 20;
     swap( a ,b );
     printf("\n a = %d, b = %d ", a, b);
     return 0;
}
void swap( int x, int y )
{
     int t;
     t = x;
     x = y;
     y = t;
     printf("\nx = %d, y = %d", x, y);
}
The output of the above program would be:
     X = 20 y = 10
A = 10 b = 20
Note that value of a and b remain unchanged after exchanging the value of x and y.
3. Call by Reference
This time the addresses of actual arguments in the calling function are copied into formal arguments of the called function. This means that using these addresses we would have an access to the actual arguments and hence we would be able to manipulate them. The following program illustrates this fact.
     * 41_callbyref.c */

void swap( int *x, int *y )

int main()
{
     int a = 10, b = 20;
     swap( &a, &b);
     printf("\na = %d, b = %d", a, b);
     return 0;
}

void swap( int *x, int *y )
{
     int t;
     t = *x; *x = *y; *y = t;
}
The output of the above program would be:
     A = 20, b = 10
Note that this program manages to exchange the values of a and b using their addresses stored in x and y. Usually in C programming we make a call by value. I.e. in general you cannot alter the actual arguments. But if desired, it can always be achieved through a call by reference.
Using call by Reference intelligently we can make a function, which can return more than one value at a time, which is not possible ordinarily. This is shown in the program given below.
     /* 42_callbyref.c */

void areaperi(int r, float *a, float *p)

int main()
{
     int radius;
     float area, perimeter;
     printf("\nEnter radius of a circle :"); scanf("%d", &radius);

     areaperi(radius, &area, &perimeter);

     printf("\nArea = %f ", area);
     printf("\nPerimeter = %f", perimeter);
     return 0;
}

void areaperi(int r, float *a, float *p)
{
     *a = 3.14 * r * r;
     *p = 2 * 3.14 * r;
}
And here is the output:
     Enter radius of a circle 5
Are = 78.500000
Perimeter = 31.400000
Here, we are making a mixed call, in the sense, we are passing the value of radius but, address of area and perimeter. And since we are passing the addresses, any change that make in values stored at address contained in the variables a and p, would make the change effective in main. That is why when the control returns from the function areaperi( ) we are able to output the values of area and perimeter.
Thus, we have been able to return two values from a called function, and hence, have overcome the limitation of the return statement, which can return only one value from a function at a time.

VII. Local Vs Global Variables
According to the Scope of Identifiers Variables are declared as of types.
     /* 42_globalid.c */
int i=4000; /* Global variable declaration*/
int main()
{
     int a=10, b=20; /* Local Variable */
     int i=100; /* Local Variable */
     printf(“%d %d”, a, b);
     printf(“\nLocal i : %d”, i); /* Accessing Local variable */
     printf(“\nGlobal i : %d “, ::i); /* Accessing Global variable */
     return 0;
}
Note: Scope Resolution ( :: ) Operator can be available in C++ only.

VIII. Storage Class Specifiers
Until this point of view we are already familiar with the declaration of variables. To fully define a variable one needs to mention not only its ‘type’ but also its ‘Storage Class’.
According to this section variables are not only have a ‘data type’, they also have a ‘Storage Class’.
Storage Classes are of 4 Types
     1. Automatic Storage Class
2. Register Storage Class
3. Static Storage Class
4. External Storage Class
1. Automatic Storage Class
     Keyword     auto
     Storage     Memory
     Default Value     Null
     Scope     Local to the block in which  the variable defined
     Life     Until the execution of its block
Eg:
     /* 43_auto.c */
#include <stdio.h>
int main()
{
     auto int i, j;
     printf(“%d %d”, i, u);
     return 0;
}
2. Register Storage Class
     Keyword     register
     Storage     CPU Registers
     Default Value     Null
     Scope     Local to the block in which the variable defined
     Life     Until the execution of its block
Eg:
     /* 44_register.c */
#include <stdio.h>
int main( )
{
     register int i, j;
     for(i=1;i<=10;i++)
          printf(“\n%d”, i);
     return 0;
}
3. Static Storage Class
     Keyword     static
     Storage     Memory
     Default Value     Zero
     Scope     Local to the block in which   the variable defined
     Life     Value of the variable persists between different function calls
Eg:
     /* 45_static.c */
#include <stdio.h>
void add();
int main()
{
     add();
     add();
     add();
     return 0;
}
void add()
{
     static int i = 1;
     printf(“%d\n”,i++);
}
4. External Storage Class
     Keyword     extern
     Storage     Memory
     Default Value     Zero
     Scope     Global
     Life     As long as the program’s execution doesn’t come to an end
Eg:
     /* 46_extern.c */
#include <stdio.h>
int i;
void add(); /* Extern variable */
int main( )
{
     extern j=10; /* Extern variable */
     for(i=1;i<=10;i++)
          add();
     return 0;
}
void add( )
{
     j++;
     printf(“%d %d\n”, i, j);
}


0 comments:

Post a Comment