Learning C/C++ Step-By-Step - Page 6

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);
}