Chapter 6 - Functions

A function is a group of statements that together perform a task. Every C program has
at least one function, which is main(), and all the most trivial programs can define
additional functions.
You can divide up your code into separate functions. How you divide up your code
among different functions is up to you, but logically the division is such that each
function performs a specific task.
A function declaration tells the compiler about a function's name, return type, and
parameters. A function definition provides the actual body of the function.
The C standard library provides numerous built-in functions that your program can call.
For example, strcat() to concatenate two strings, memcpy() to copy one memory
location to another location, and many more functions.
A function can also be referred as a method or a sub-routine or a procedure, etc.

Defining a Function
The general form of a function definition in C programming language is as follows −
return_type function_name(parameter list)
{
body of the function
}
dummy()
{
}
A function definition in C programming consists of a function header and a function
body. Here are all the parts of a function −
 Return Type − A function may return a value. The return_type is the data type
of the value the function returns. Some functions perform the desired operations
without returning a value. In this case, the return_type is the keyword void.
 Function Name − This is the actual name of the function. The function name
and the parameter list together constitute the function signature.
 Parameters − A parameter is like a placeholder. When a function is invoked,
you pass a value to the parameter. This value is referred to as actual parameter
or argument. The parameter list refers to the type, order, and number of the
parameters of a function. Parameters are optional; that is, a function may
contain no parameters.
  Function Body − The function body contains a collection of statements that
define what the function does.

Example
Given below is the source code for a function called max(). This function takes two
parameters num1 and num2 and returns the maximum value between the two −
/* function returning the max between two numbers */
int max(int num1, int num2) {

/* local variable declaration */

int result;

if (num1 > num2)

result = num1;
else
result = num2;

return result;
}

Function Declarations
A function declaration tells the compiler about a function name and how to call the
function. The actual body of the function can be defined separately.
A function declaration has the following parts −
return_type function_name( parameter list );
For the above defined function max(), the function declaration is as follows −
int max(int num1, int num2);
Parameter names are not important in function declaration only their type is required,
so the following is also a valid declaration −
int max(int, int);
Function declaration is required when you define a function in one source file and you
call that function in another file. In such case, you should declare the function at the top
of the file calling the function.

Calling a Function
While creating a C function, you give a definition of what the function has to do. To use
a function, you will have to call that function to perform the defined task.
When a program calls a function, the program control is transferred to the called
function. A called function performs a defined task and when its return statement is
executed or when its function-ending closing brace is reached, it returns the program
control back to the main program.
To call a function, you simply need to pass the required parameters along with the
function name, and if the function returns a value, then you can store the returned
value. For example −
Live Demo
#include <stdio.h>

/* function declaration */
int max(int num1, int num2);

int main () {

/* local variable definition */

int a = 100;
int b = 200;
int ret;

/* calling a function to get max value */

ret = max(a, b);

printf( "Max value is : %d\n", ret );

return 0;
}

/* function returning the max between two numbers */

int max(int num1, int num2) {

/* local variable declaration */

int result;

if (num1 > num2)

result = num1;
else
result = num2;

return result;
}

We have kept max() along with main() and compiled the source code. While running
the final executable, it would produce the following result −
Max value is : 200
Character functions
 All these functions have return type int.These functions are declared In the header file
#include<ctype.h>

(I) i)isdigit(c)
To check whether a character is a digit or not

(II) ii)isxdigit(c)
to check whether a character is a hexadecimal digit

(III) isalpha(a)
to check if the character is an alphabet

(IV) isalnum(c)
to check if the charcter is alphabetic or numeric

(V) islower(c)
to check if it is lower case alphabet

(VI) isspace(c)
checks all white spaces characters

(VII) isupper(c)
to check for uppercase alphabet

(VIII) tolower(c) A-a

to convert an uppercase character to lowercase

(IX) toupper(c) a
to convert a lower case(small letters) character to uppercase(capital letters)

(X) isprint(c)
to check whether a character is a printing character including space

“string” functions
these functions are declared in the header file #include<string.h>
I. strcpy (s1, s2)
copies s2 to s1

II. strncpy (s1, s2, n)

copies s2 to s1 until either Null character is reached or n character have
been copied whichever occurs first.

Example: char a [10], b [10] =” hello”;

strcpy (a, b);
Puts(a);
Will display hello
 Example: char a [20], b [20] =” student”; a[0]=’s’ ,a[1]=’t’, a[2]=’u’
Strncpy (a, b,3);
Now a [0], a [1], a will store ‘s’,’t’ ad ‘u’ respectively.

III. Int strcmp (char s 1[], char s2[])

-compares s1 and s2
-returns = 0 if strings are equal
-returns>0 if s1>s2
-return<0 if s1<s2
Hello, Hello
Example if ((strcmp (a, b) ==0)
Implies that if a & b are equal

IV. Int strncmp (char s1[], char s2[], int n)

–compares n characters
–returns the same value as strcmp

Example: strncmp (s1, s2,4)

Will compare the first 4 bytes of s1 and s2

V. Int strlen (char s [])

–returns length of the string (excluding null)

Strcat (s1, s2)-concatenates s2 to the end of s1 and places a null at the

end of the final string

Example: strcat (a, b)

Puts(a);
VI. Strncat (s1, s2, n)
–appends n characters of s2 at the end of s1.

Mathematical functions
(i) These functions are declared in the header file #include<math.h>Trigonometric
functions like sin, cos, tan, asin, acos, atan, sinh, cosh. Each function has double
argument and return type is also double. Angle is handled in terms of radians.

(ii) double exp(double x) Eg: x4 =x*x*x*x x4=1.5*1.5*1.5*1.5

 (iii) double log(double x)

(iv) double log 10(double x)

(v) double pow (double x, double y)

(vi) double fabs (double x), returns absolute value

(vii) double sqrt (double x)

(viii) double ceil (double x), his returns the smallest integer not less than x

(ix) double floor (double x), this returns the largest integer not greater than x

Function prototype
A function prototype is simply the declaration of a function that specifies
function's name, parameters and return type. It doesn't contain function body.

A function prototype gives information to the compiler that the function may
later be used in the program.
 Syntax of function prototype

returnType functionName(type1 argument1, type2 argument2, ...);

In the above example,  int addNumbers(int a, int b);  is the function prototype
which provides the following information to the compiler:
1. name of the function is  addNumbers()
2. return type of the function is  int
3. two arguments of type  int  are passed to the function
The function prototype is not needed if the user-defined function is defined
before the  main()  function.

Difference between Local and Global

Variable
What is a Variable?
#include<stdio.h>
Main()
{
Int y,x;

Variable is a name assign to a storage area that the program can manipulate.
A variable type determines the size and layout of the variable's memory.

It also determines the range of values which need to be stored inside that
memory and nature of operations that can be applied to that variable.
Scope of Variables
The scope of the variable is simply lifetime of a variable. It is block of code
under which a variable is applicable or alive. For example:

function foo()
{
var x;
}

You declare a variable "x" inside a function "foo." The scope of that variable
remains inside that function it can't be used outside of that function.

There are three places where variables you can declare variable programming
language:

 Inside a function or a block: Local variables

 Outside of all functions: Global variables
 In the definition of function parameters: Formal parameters

Definition of Local Variable

A local variable is a type of variable declared within programming block or
subroutines. It can only be used only inside that subroutine or code block in
which they were declared. The local variable exists until the block of the
function is in under execution. After that, it will be destroyed automatically.

Example of Local Variable

public int add()

{
int a =4;
int b=5;
return a+b;
}

Here, 'a' and 'b' are local variables

Definition of Global Variable

 Global variables are defined outside of a subroutine or function. The global
variable will hold its value throughout the lifetime of a program. They can be
accessed within any function defined for the program.

Example:

int a =4;
int b=5;

public int add(){

return a+b;
}

Here, 'a' and 'b' are global variables.

Use of return statement
return statement terminates a function and transfer program control to its caller
function. Optionally it may return a value to the caller. You can use
the return statement anywhere inside a function.
Note: Once a function returned program control to the
caller. The function cannot get the control back.

Syntax of return statement
return expression;
 return keyword transfers program control to the caller.
 expression is optional, used to return result of a valid C expression to the caller.

Note: The function return type and returned value type (data type) of the function must
be same.
Passing Arguments to Functions
You can pass data to functions so they can work on that data. For example, you can create a function
named adder() that you want to add two integers and display the results.

To indicate which arguments a function takes, you include an argument list in the parentheses following the
function name when you define the function. For example, the adder()function takes two arguments: the two
integers to add, which we’ll name x and y:

void adder(int x, int y)

Now in the body of the function, you can refer to the first argument as x and the second argument as y.

When you create a function prototype, on the other hand (when you call the function before defining it in your
code), you omit the names of the arguments, instead including just the type:

void adder(int, int);

Now you can write the body of the adder() function to add the two integers, which you can refer to by
name, x and y:
void adder(int x, int y)

printf("%i + %i = %i", x, y, x + y);

Pass arrays to a function in C

Passing more than one variable of the same type to a function is required by various general
problems in the C language. It is seen as an important task to Pass arrays to a function in C as
to be passed as the actual parameters from the main function some amount of numbers is
required. For instance, a function in C that sorts the 10 elements in the ascending order. In order
to be passed as the actual parameters from the main function, these type of function will require
10 numbers. In this case, instead of declaring those 10 numbers that are different from each
other and then passing into the function, Users can declare and initialize an array and pass that
into the function, instead of declaring 10 different numbers and then passing into the function.
Doing this will automatically resolve all the complexity as the function will now work for any
number of provided values.

Function Arguments
If a function is to use arguments, it must declare variables that accept the values of the
arguments. These variables are called the formal parameters of the function.
Formal parameters behave like other local variables inside the function and are created
upon entry into the function and destroyed upon exit.
While calling a function, there are two ways in which arguments can be passed to a
function −

Sr.No. Call Type & Description

 1 Call by value

This method copies the actual value of an argument into the formal parameter of
the function. In this case, changes made to the parameter inside the function
have no effect on the argument.

2 Call by reference
This method copies the address of an argument into the formal parameter. Inside
the function, the address is used to access the actual argument used in the call.
This means that changes made to the parameter affect the argument.

By default, C uses call by value to pass arguments. In general, it means the code

within a function cannot alter the arguments used to call the function.

Difference between Call by Value and Call by

Reference
Functions can be invoked in two ways: Call by Value or Call by Reference. These two
ways are generally differentiated by the type of values passed to them as parameters.
The parameters passed to function are called actual parameters whereas the
parameters received by function are called formal parameters.
Call By Value: In this parameter passing method, values of actual parameters are
copied to function’s formal parameters and the two types of parameters are stored in
different memory locations. So any changes made inside functions are not reflected in
actual parameters of caller.
Call by Reference: Both the actual and formal parameters refer to same locations, so
any changes made inside the function are actually reflected in actual parameters of
caller.
CALL BY VALUE CALL BY REFERENCE

While calling a function, instead of passing the values of

While calling a function, we pass values of variables to variables, we pass address of variables(location of

it. Such functions are known as “Call By Values”. variables) to the function known as “Call By References.
 CALL BY VALUE CALL BY REFERENCE

In this method, the value of each variable in calling function In this method, the address of actual variables in the calling

is copied into corresponding dummy variables of the called function are copied into the dummy variables of the called

function. function.

With this method, the changes made to the dummy variables With this method, using addresses we would have an access to

in the called function have no effect on the values of actual the actual variables and hence we would be able to manipulate

variables in the calling function. them.

&=adress

// C program to illustrate // C program to illustrate

// call by value // Call by Reference

     

#include <stdio.h> #include <stdio.h>

     

// Function Prototype // Function Prototype

void swapx(int x, int y); void swapx(int*, int*);

     

// Main function // Main function

int main() int main()

{ {

    int a = 10, b = 20;     int a = 10, b = 20;

     

    // Pass by Values     // Pass reference

    swapx(a, b);     swapx(&a, &b);

     

    printf("a=%d b=%d\n", a, b);     printf("a=%d b=%d\n", a, b);

     
 CALL BY VALUE CALL BY REFERENCE

    return 0;

  

// Swap functions that swaps     return 0;

// two values }

void swapx(int x, int y)   

{ // Function to swap two variables
    int t; // by references

   void swapx(int* x, int* y)

    t = x; {

    x = y;     int t;

    y = t;   

       t = *x;

    printf("x=%d y=%d\n", x, y);     *x = *y;

}     *y = t;

Output:   

    printf("x=%d y=%d\n", *x, *y);

Output:

x=20 y=10 x=20 y=10

a=10 b=20 a=20 b=10
Exercises
Q2 write a function int power(int x,int n) to return xn

int power(int x,int n)

{
if( n == 0)
return 1;

return x*power(x, --n);

}

int main()
{
int x = 2;
int n = 3;

printf("%d", power(x, n));

return 0;
}
Q4 write a function to return the factorial of a number
#include <stdio.h>
 
int fact(int);
 
void main()
{
int no,factorial;

  printf("Enter a number to calculate it's factorial\n");

  scanf("%d",&no);
 factorial=fact(no);
  printf("Factorial of the num(%d) = %d\n",no,factorial);
//printf("Factorial of the num(%d) = %d\n",no,fact(no));//another way of calling a function//comment above two lines if you want
to use this
}
 
int fact(int n)
{
    int i,f=1;
    for(i=1;i<=n;i++)
    {
        f=f*i;
    }
    return f;
}
Q6 write a function int isPrime(int n) that returns 1 if its argument is a prime
number,else returns 0.
#include<stdio.h>
int isPrime(int);
main()
{
int n, result;

printf("Enter an integer to check whether it is prime or not.\n");

scanf("%d",&n);

result = isPrime(n);

if ( result == 1 )
printf("%d is prime.\n", n);
else
printf("%d is not prime.\n", n);

return 0;
}

int isPrime(int a)
{
int c;

for ( c = 2 ; c <= a - 1 ; c++ )

{
if ( a%c == 0 )
return 0;
}
return 1;
}
Q14 write a function int Len(char s[]) to return the length of a string s.
#include <stdio.h>
int main()
{
char s[1000];
int c = 0;

printf("Input a string\n");
gets(s);

while (s[c] != '\0')

c++;

printf("Length of the string: %d\n", c);

return 0;
}
/*Function to find string length:*/

int Len(char s[]) {

int c = 0;
while (s[c] != '\0')
c++;

return c;
}