User defined functions in C programmig

USER-DEFINED FUNCTIONS

INTRODUCTION

• C functions can be classified into two categories– Library functions– User-defined functions

LIBRARY FUNCTIONS

– Library functions are not required to be written by us

– printf and scanf belong to the category of library function

– sqrt, cos, strcat, etc are some of library functions

USER-DEFINED FUNCTIONS

– User-defined functions has to be developed by the user at the time of writing a program

– A user-defined functions can later become a part of the C program library

– main is an example of user-defined functions

NEED FOR USER-DEFINED FUNCTIONS

• Every program must have a main function• It is possible to code any program utilizing only main

function, it leads to a number of problems• The program may become too large and complex and

as a result the task of debugging, testing, and maintaining becomes difficult

• If a program is divided into functional parts, then each part may be independently coded and later combined into a single unit

• These subprograms called ‘functions’ are much easier to understand, debug, and test

NEED FOR USER-DEFINED FUNCTIONS• There are times when some types of operation or

calculation is repeated at many points throughout a program

• In such situations, we may repeat the program statements whenever they are needed

• Another approach is to design a function that can be called and used whenever required

• This saves both time and space

NEED FOR USER-DEFINED FUNCTIONS• This sub-sectioning approach clearly results in a

number of advantages– It facilitates top-down modular programming. – The length of a source program can be reduced by using

functions at appropriate places. This factor is particularly critical with microcomputers where memory space is limited

– It is easy to locate and isolate a faulty function for further investigations

– A function may be used by many other programs, this means that a C program can build on what others have already done, instead of starting over, from scratch.

A MULTI-FUNCTION PROGRAM• A function is a self-contained block of code that

performs a particular task• Once a function has been designed and packed, it can

be treated as a ‘black box’ that takes some data from the main program and returns a value

• The inner details are invisible to the rest of the program• Example:

main(){ printline(); printf("This illustrated the use of C functions \n"); printline();}printline(){ int i; for(i=1; i<40; i++) pintf("-"); printf("\n");}

ELEMENTS OF USER-DEFINED FUNCTIONS

• Functions are classified as one of the derived data types in C• Can define functions and use them like any other variables in

C programs.• Similarities between functions and variables in C

– Both function name and variable names are considered identifiers and therefore they must adhere to the rules for identifiers.

– Like variables, functions have types (such as int) associated with them

– Like variables, function names and their types must be declared and defined before they are used in a program

ELEMENTS OF USER-DEFINED FUNCTIONS

• There are three elements related to functions– Function definition– Function call– Function declaration

• The function definition is an independent program module that is specially written to implement the requirements of the function

• To use this function we need to invoke it at a required place in the program. This is known as the function call.

• The program that calls the function is referred to as the calling program or calling function.

• The calling program should declare any function that is to be used later in the program. This is known as the function declaration or function prototype.

FUNCTION

DEFINITION OF FUNCTIONS• A function definition, also known as function

implementation shall include the following elements;– Function name;– Function type;– List of parameters;– Local variable declaration;– Function statements; and– A return statement.

• All six elements are grouped into two parts, namely,– Function header (First three elements); and– Function body (Second three elements)

THE FORM OF C FUNCTIONfunction_type function_name(parameter list){ local variable declaration; executable statement1; executable statement2; ---------------- ---------------- return(expression);}

• The first line function_type function_name(parameter list) is known as the function header.

• The statements within the opening and the closing brace constitute the function body.

FUNCTION DEFINITION• Function Header

– The function header consists of three parts: the function type (also known as return type), the function name and formal parameter list.

– Semicolon is not used at the end of the function header

• Name and Type– The function type specifies the type of value (like float or double) that

the function id expected to return to the program calling the function– If the return type is not explicitly specified, C assume it as an integer

type.– If the function is not returning anything then we need to specify the

return type as void– The function name is any valid C identifier and therefore ,just follow the

same rules of formation as other variable names in C

FORMAL PARAMETER LIST• The parameter list declares the variables that will receive the

data sent by the calling program.• They serve as input data to the function to carry out the

specified task.• They represent actual input values, they are often referred to

as formal parameters.• These parameters can also be used to send values to the

calling programs• The parameter is known as arguments.

– float quadratic (int a, int b, int c) { ….. }– double power (double x, int n) { ….. }– int sum (int a, int b) { ….. }

• There is no semicolon after the closing parenthesis• The declaration parameter variables cannot be combined

FORMAL PARAMETER LIST• To indicate that the parameter list is empty, we use the

keyword void between the parentheses as invoid printline (void){ …}

• Many compiler accept an empty set of parenthesesvoid printline()

• It is good to use void to indicate a nill parameter list

FUNCTION BODY• The function body contains the declarations and statements

necessary for performing the required task. The body enclosed in braces, contains three parts,– Local declarations that specify the variables needed by the function– Function statements that perform the task of the function– A return statement that returns the value evaluated by the function

• If a function does not return any value, we can omit the return statement.

• Its return type should be specified as void

RETURN VALUES AND THEIR TYPES• A function may or may not send back any value to

the calling function• Done through return statement• It is possible to send any number of values to the

called function• The called function can only return one value per call• SYNTAX:

return;orreturn (expression);

RETURN VALUES AND THEIR TYPES• return;

– Plain return does not return any value– Acts as the closing brace of the function– The control is immediately passed back to the calling function– EXAMPLE:

if(error) return;

• return (expression);– Return the value of the expression

• EXAMPLE:mul(x,y)int x,y;{ int p; p = x*y; return(p);}

– Returns the value of p which is the product of the values of x and y– The last statement can be combined into one statement as

return(x*y);

RETURN VALUES AND THEIR TYPES• A function may have more than one return statements• This situation arises when the value returned is based

on certain conditions• EXAMPLE:

if(x <= 0) return(0);else return(1);

• Return type of data:– All function by default return int type data– We can force a function to return a particular type of data

by using type specifier in the function header– EXAMPLE:

double product(x,y)float sqr_root(p)

– When a value is returned, it is automatically cast to the function’s type

CALLING A FUNCTION• A function can be called by simply using the function

name in a statement• When the function encounters a function call, the

control is transferred to the function mul(x,y)main(){ int p; p = mul(10,5); printf("%d\n", p);}int mul(int x,int y){int p; /*local variables*/p = x * y;/* x = 10, y = 5*/return(p);}

CALLING A FUNCTION• The function is executed and the value is returned

and assigned to p• A function which returns a value can be used in

expressions like any other variablesprintf("%d\n", mul(p,q));y = mul(p,q) / (p+q);if (mul(m,n)>total) printf("large");

• A function cannot be used on the right side of an assignment statement

mul(a,b) = 15;

• A function that does not return any value may not be used in expression; but can be called to perform certain tasks specified in the function

main() { printline(); }

FUNCTION DECLARATION• A function declaration consists of four parts

– Function type (return type)– Function name– Parameter list– Terminating semicolon

• Format– Function-type function-name (parameter list);

• Very similar to the function header line expect the terminating semicolon.– int mul(int m, int n); /* Function prototype */

• Equally acceptable forms of declarations are– int mul (int, int);– mul (int a, int b);– mul (int, int);

FUNCTION DECLARATION• When a function does not take any parameters and does not

return any value, its prototype is written as:void display (void);

• A prototype declaration may be placed in two places in a program.– Above all the functions (including main) (global prototype)– Inside a function definition (local prototype)

• It is good to declare prototypes in the global declaration section before main.

• It adds flexibility, provides an excellent quick reference to the functions used in the program, and enhances documentation

CATEGORY OF FUNCTIONS

• Category 1: Functions with no arguments and no return values

• Category 2: Functions with arguments and no return values

• Category 3: Functions with arguments and one return values

• Category 4: Functions with no arguments but return a value

• Category 5: Functions that return multiple values

NO ARGUMENTS AND NO RETURN VALUES

• When a function has no arguments, it does not receive any data from the calling function

• When it does not return a value, the calling function does not receive any data from the called function

• There is no data transfer between the calling function and the called function

• There is only a transfer of control but not data

EXAMPLE#include <stdio.h>#include<conio.h>void add(void);void main() //calling function{

add();}add() //called function{ int a,b,c; printf("\nEnter two number:"); scanf("%d%d",&a,&b); c=a+b; printf("\nSum is:%d",c);}

OUTPUT:Enter two number:34

Sum is:7

ARGUMENTS BUT NO RETURN VALUES

• The calling function read data from the terminal and pass it on to the called function.

• It is a one way data communication, i.e. the called program receives data from calling program but it does not return any value to the calling program.

• This approach is wiser because the calling function can check for the validity of data, if necessary, before it is handed over to the called function.

• Called function with argumentsvalue(p,r,n)


• The function callvalue(500,0.12,5)

• Would send the value 500, 0.12, 5 to the functionvalue(float p, float r, int n)

• and assign 500 to p, 0.12 to r and 5 to n• The values 500, 0.12, 5 are the actual arguments• The arguments p, r, n are the formal arguments• The actual and formal arguments should match in

number, type, and order• The values of actual arguments are assigned to the

formal arguments on a one to one basis


• if the actual arguments are more than the formal arguments, the extra actual arguments are discarded

• If the actual arguments are less than the formal arguments, the unmatched formal arguments are initialized to some garbage values

• No error message will be generated• The formal arguments must be valid variable names• The actual arguments my be variable names,

expression, or constants• When a function call is made, only a copy of the

values of actual arguments is passed into the called function

EXAMPLE#include <stdio.h>#include<conio.h>add(int, int);void main(){

int a,b;printf("\nEnter two number:");scanf("%d%d",&a,&b);add(a,b);

}

add(int x, int y) //function with arguments{ int z; z=x+y; printf("\nSum is:%d",z);}


Sum is:6

ARGUMENTS WITH RETURN VALUES• Here data transfer take place between the calling

function and the called function as well as between called function and calling function .

• It is a two way data communication, i.e. the called program receives data from calling program and it return some value to the calling program.

• A self-contained and independent function should behave like a ‘black box’ that receives a predefined form of input and outputs a desired value

EXAMPLE#include <stdio.h>#include<conio.h>add(int, int);void main(){

int a,b;float c;printf("\nEnter two number:");scanf("%d%d",&a,&b);c=add(a,b);printf("\nSum is:%f",c);

}

add(int x, int y){ float z; z=x+y/3; return(z);}


Sum is:13

RETURNING FLOAT VALUE

• C function returns a value of the type int as a default case when no other type is specified explicitly.return(z);

• Return the integer value of sum• This is due to the absence of the type-specifier in the

function header• There will be times when we may find it necessary to

receive the float or double type of data• We must explicitly specify the return type on both the

function definition and the prototype declaration

EXAMPLE#include <stdio.h>#include<conio.h>float add(int, int);void main(){

int a,b;float c;printf("\nEnter two number:");scanf("%d%d",&a,&b);c=add(a,b);printf("\nSum is:%f",c);

}

float add(int x, int y){ float z; z=x+y/3; return(z);}


Sum is:13

RETURNING NON-INTEGER VALUE• The type-specifier tells the

compiler, the type of data the function is to return

• The called function must be declared at the start of the body in the calling function, like any other variable. This is to tell the calling function the type of data that the function is actually returning

float mul(float, float);double div(float, float);main() { float a,b; a = 12.345; b = 9.82; printf("%f\n", mul(a,b)); printf("%f\n", div(a,b));}float mul(float x,float y){ return(x*y); }double dic(float p, float q){ return(p/q); }

NO ARGUMENTS BUT RETURNS A VALUE

• There could be occasions where we may need a design functions that may not take any arguments but returns a value to the calling function.

int get_number(void);main(){int m = get_number();printf(“%d”,m);}int get_number(void){int number;scanf(“%d”, &number);return(number);}

FUNCTIONS RETURNING NOTHING• Functions that do not return

any values are not declared in the main

main(){ printline(); value(); printline();}printline(){ ....}value(){ ....}

• We can also declare them in the main with the qualifier void

• This states explicitly that the functions do not return values

main(){ void printline(); void value(); void printline();}void printline(){ ....}void value(){ ....}

FUNCTIONS THAT RETURN MULTIPLE VALUES

• A return statement can return only one value.• To get more information from a function, we can

achieve this in C using the arguments not only to receive information but also to send back information to the calling function.

• The arguments that are used to “send out” information are called output parameters.

• The mechanism of sending back information through arguments is achieved using what are known as the address operator (&) and indirection operator (*).

PROGRAMvoid mathoperation(int x, int y, int *s, int *d);main(){ int x = 20, y = 10, s, d; mathoperation(x,y,&s,&d); printf("s=%d\n d=%d\m", s,d);}void mathoperation(int x, int y, int *sum, int

*diff){ *sum = a+b; *diff = a-b;}

• x and y – input arguments• s and d – output arguments• We pass

– Value of x to a– Value of y to b– Address of s to sum– Address of d to diff

• The body of the function when executed add the value and find difference and store the result in memory location pointed by sum and diff.

FUNCTIONS THAT RETURN MULTIPLE VALUES

• The indirection operator * indicates the variables are to store addresses, not actual values of variables

• The operator * is known as indirection operator because it gives an indirect reference to a variable through its address

• The variables *sum and *diff are known as pointers and sum and diff as pointer variables

• They are declared as int, they can point to locations of int type data

• The use of pointer variables as actual parameters for communicating data between functions is called “pass by pointers” or “call by address or reference”.

NESTING OF FUNCTIONS• C permits nesting of functions freely• main can call function1, which calls function2, which

calls function3, …..and so on

RECURSION• When a called function in turn calls another function a

process of ‘chaining’ occurs• Recursion is a special case, where a function calls itself• EXAMPLE:

main(){ printf("This is an example of recursion\n"); main();}

• OUTPUT:This is an example of recursionThis is an example of recursionThis is an example of recursionThis is an exa

• Execution is terminated abruptly

EXAMPLE#include<stdio.h>#include<conio.h>void main(){ int a; int factorial (int); printf("\nEnter the number:"); scanf("%d",&a); printf("The factorial of %d! is

%d",a,factorial(a));}

int factorial(int x){ int f; if(x==1)

return(1); else

f=x*factorial (x-1); return(f);}

OUTPUT:Enter the number:5The factorial of 5! is 120

FUNCTIONS WITH 1D ARRAYS• Possible to pass the values of an array to a function• To pass an array to a called function, it is sufficient to

list the name of the array without any subscripts, and the size of the array as arguments

• The call:largest(a,n);

• will pass all the elements contained in the array a of size n.

• The called function expecting this call must be appropriately defined

• The largest function header isfloat largest(float array[], int size)

FUNCTIONS WITH 1D ARRAYS• The function header(largest) is defined to take two

arguments, the array name and the size of the array to specify the number of elements in the array

• The declaration of formal argument array isfloat array[];

• The pair of brackets informs the compiler that the arguments array is an array of numbers

• It is not necessary to specify the size of the array here

FUNCTIONS WITH 1D ARRAYS• Here an array is transferred as parameter to a

function.void main() void fun(int b[], int n){ {void fun(int[],int); int x,b[5];int a[5],n; …………..…………… …………..fun(a,n);…………… }}

EXAMPLE#include<stdio.h>#include<conio.h>void add(int[],int b);void main(){ int a[5],i,n; clrscr(); printf("\n Enter the Number: "); scanf("%d",&n); printf("\n Enter the Values: ");for(i=0;i<n;i++)

scanf("%d",&a[i]); add(a,n); }

void add(int b[],int x) { int sum=0,i; for(i=0;i<x;i++)

sum=sum+b[i]; printf("\nThe sum is: %d",sum); }OUTPUT:Enter the Number: 5Enter the Values: 12345The sum is: 15

FUNCTIONS WITH 2D ARRAYS

• Can also pass multi-dimensional arrays to functions. The rules are:– The function must be called by passing only the array

name– In the function definition, we must indicate that the array

has two-dimensional by including two sets of brackets– The size of the second dimension must be specified– The prototype declaration should be similar to the

function header

PROGRAMmain(){ int M=3, N=2; float average(int [][N], int, int); float mean; int matrix[M][N] = { {1,2}, {3,4},

{5,6} }; mean = average(matrix, M, N);}

float average(int x[][N], int M,int N)

{ int i, j; float sum = 0.0; for(i=0; i<M; i++) for(j=0; j<N; j++) sum+=x[i][j]; return(sum/(M*N));}

PASSING STRINGS TO FUNCTIONS

• The strings are treated as character arrays in C and therefore the rules for passing strings to function are very similar to those for passing arrays to functions

• Basic rules are– The string to be passed must be declared as a formal

argument of the function when it is definedExample:void display(char item_name[]){...}

PASSING STRINGS TO FUNCTIONS– The function prototype must show that the argument is a

string void dispay(char str[]);

– A call to the fuction must have a string array name without subscripts as its actual argument

Example:display(names);

Name is a properly declared string array in the calling function

• Like arrays, strings in C cannot be passed by value to function

THE SCOPE, VISIBILITY AND LIFETIME OF VARIABLES

• It is very important to understand the concept of storage classes and their utility in order to develop efficient multifunction programs

• In C there are four storage classes– Automatic variables– External variables– Static variables– Register variables

• Here we discuss the scope, visibility and longevity of the above class of variables

THE SCOPE AND LIFETIME OF VARIABLES IN FUNCITONS

• SCOPE OF VARIABLE– Determines over what parts of the program a variable is actually

available for use (active)• LONGEVITY

– Refers to the period during which a variable retains a given value during execution of program (alive)

– It has a direct effect on the utility of a given variables• VISIBILITY

• The visibility refers to the accessibility of a variable from the memory

• Variables are categorized depending on the place of their declaration– Internal (local)

• Internal variables are those which are declared within a particular function

– External (global)• External variables are declared outside of any function

AUTOMATIC VARIABLES• Automatic variables are declared inside a function in

which they are to be utilized• They are created when the function is called and

destroyed automatically when the function is exited, hence the name automatic

• Automatic variables are therefore private to the function in which they are declared

• Automatic variables are also referred to as local or internal variables

AUTOMATIC VARIABLES• A variable declared inside a function without storage

class specification is, by default, an automatic variable• The storage class of the variable number is automatic

main(){ int number; .......}

• We may also use the keyword auto to declare automatic variables explicitly

main(){ auto int number; .......}

EXAMPLEvoid function1(void);void function2(void);main(){ int m = 1000; function2();printf("%d\n",m);}void function1(void){ int m = 10; printf("%d\n",m);}

void function2(void){ int m = 100; function1(); printf("%d\n",m);}

EXAMPLEvoid function1(void);void function2(void);main(){ int m = 1000; function2();printf("%d\n",m);}void function1(void){ int m = 10; printf("%d\n",m);}

void function2(void){ int m = 100; function1(); printf("%d\n",m);}OUTPUT:101001000

AUTOMATIC VARIABLES

• There are two consequences of the scope and longevity of auto variables

• Any variable local to main will normally live throughout the whole program, although it is active only in main.

• During recursion, the nested variables are unique auto variables

EXTERNAL VARIABLES

• Variables that are both alive and active throughout the entire program are known as external variables

• They are also known as global variables• Global variables can be accessed by any function in

the program• External variables are declared outside a function

EXTERNAL VARIABLESint number;float length = 7.5;main){.....}function1(){ .....}function2(){.....}

• The variables number and length are available for use in all the three functions

• In case a local variables and a global variable have the same name, the local variable will have precedence over the global one in the function where it is declared

EXTERNAL VARIABLESint count;main(){ count = 10; .....}function(){ int count = 0; .... count = count+1;}

• When the function references the variable count, it will be referencing only its local variable, not the global one

• The value of count in main will not be affected

EXAMPLEint fun1(void);int fun2(void);int fun3(void);int x;main(){ x = 10; printf("x = %d\n",x); printf("x = %d\n",fun1()); printf("x = %d\n",fun2()); printf("x = %d\n",fun3());}fun1(void){ x = x + 10;}

fun2(void){ int x x = 1; return(x);}fun3(void){ x = x + 10;}

EXAMPLEint fun1(void);int fun2(void);int fun3(void);int x;main(){ x = 10; printf("x = %d\n",x); printf("x = %d\n",fun1()); printf("x = %d\n",fun2()); printf("x = %d\n",fun3());}fun1(void){ x = x + 10;}

fun2(void){ int x x = 1; return(x);}fun3(void){ x = x + 10;}OUTPUT:

x = 10x = 20x = 1x = 30

EXTERNAL VARIABLES• Once a variable has been declared as global, any function can

use it and change its value• Then subsequent functions can reference only that new value• Global variable is that it is visible only from the point of

declaration to the end of the programmain(){ y = 5; ....}int y;func1(){ y = y + 1;}

• As for as main is concerned, y is not defined. So, the compiler will issue an error message

• Global variables are initialized to zero by default• The statement y = y + 1 will assign 1 to y.

EXTERNAL DECLARATION• The main cannot access the variable y as it has been declared

after the main function• This problem can be solved by declaring the variable with the

storage class externmain(){ extern int y; /* external declaration */ ....}func1(){ extern int y; /* external declaration */ .....}int y; /* definition */

• Although the variable y has been defined after both the functions, the external declaration of y inside the function informs the compiler that y is an integer type defined somewhere else in the program

• The extern declaration does not allocate storage space for variables

EXTERNAL DECLARATIONmain(){ int i; void print_out(void); extern float height[]; ....print_out();}void print_out(void){ extern float height[]; int i; ...... .....}float height[SIZE];

• An extern within a function provides the type information to just that one function

• We can provide type information to all functions within a file by placing external declaration before any of them

EXTERNAL DECLARATION

• The distinction between definition and declaration also applies to functions

• A function is defined when its parameters and function body are specified

• This tells the compiler to allocate space for the function code and provides type information for the parameters

• Since functions are external by default, we declare them without the qualifier extern

• void print_out(); is equivalent to

• extern void print_out();

extern float height[];main(){ int i; void print_out(void); .... print_out();}void print_out(void){ int i; ......}float height[SIZE];

STATIC VARIABLES• The value of static variables persists until the end of the

program• A variable can be declared static using the keyword

staticstatic int x;static float y;

• A static variable may be an internal or external type, depending on the place of declaration

EXAMPLE

void stat(void)main(){ int i; for(i=1; i<=3; i++)

stat();}void stat(void){ static int x = 0; x = x + 1; printf("x = %d\n",x);}

OUTPUT:x = 1x = 2x = 3

• If we had declared x as an auto variable. The output would be

X = 1X = 1X = 1

STATIC VARIABLESInternal static variables• Declared inside a function• The scope extend up to end of the function in which they are

defined• Similar to auto variables, except that they remain inexistence

(alive) throughout the remainder of the program• Static variable is initialized only once, when the program is

compiled. It is never initialized again

External static variables• Declared outside of all functions and is available to all the

functions in that program• The difference between a static external variable and a simple

external variable is that:– the static external variable is available only within the file where it is

defined while the simple external variable can be accessed by other files

SCOPE OF FUNCTION

• To make a particular function accessible only to the functions in the file in which it is defined and not to any function in other files by defining that function with the storage class static

REGISTER VARIABLES• Register access is much faster than a memory access• We can make a variable to be placed in one of the

machine register instead of memory usingregister int count;

• Most compiler allow int or char variables to be placed in the register

• ANSI standard does not restrict to any particular data type

• C will automatically convert register variables into non-register variables once the limit is reached

MULTIFILE PROGRAMS• More than one source file is compiled separately and

linked later to form an executable object code• This approach is very useful because any change in

one file does not affect other files thus eliminating the need for recompilation of the entire program

• Multiple source files can share a variable declared as an external variable

• Variables that are shared by two or more files are global variables and we must declare them accordingly in one file and then explicitly define them with extern in other file

USE OF EXTERN IN A MULTIFILE PROGRAM

file1.c

main(){ extern int m; int i; ....}function1(){ int j; ....}

file2.c

int m /* global variable */function2(){ int i; .....}function3(){ int count; .....}

USE OF EXTERN IN A MULTIFILE PROGRAM

file1.c

int m; /* global variable */main(){ int i; ....}function1(){ int j; ....}

file2.c

extern int m;function2(){ int i; ....}function3(){ int count; .....}

MULTIFILE PROGRAMS• The extern specifier tells the compiler that the following

variables types and names have already been declared elsewhere and no need to create storage space for them

• It is the responsibility of the linker to resolve the reference problem

• A function defined in one file and accessed in another must include a function declaration

• The declaration identifies the function as an external function whose definition appears elsewhere

• We place such declarations at the beginning of the file, before all functions

• Although all functions are external, it would be good practice to explicitly declare such functions with storage class extern

TO FIND THE MAXIMUMmain(){ float largest(float a[],int n); float value[4] = {2.5, -4.75, 1,2. 3.6} printf("%f\n", largest(value,4));}float largest(float a[], int n){ int i; float max; max = a[0]; for(i=1;i<n;i++) if(max<a[i]) max = a[i]; return(max);}

TO SORT AN ARRAY OF INTEGERSmain(){ int i; int marks[5] = {40, 90, 73, 81, 35}; printf("Marks before sorting\n"); for(i=0;i<5;i++) printf("%d ",marks[i]); printf("\n\n"); sort(5, marks); printf("Marks after sorting\n"); for(i=0;i<5;i++) printf("%4d ",marks[i]);}

void sort(int m, int x[]){ int i,j,t; for(i=1;i<=m-1;i++) for(j=1;j<=m-i;j++) if(x[j-1]>=x[j]) { t = a[j-1]; x[j-1] = x[j]; x[j] = t; }}

SWAPPING NUMBERS USING CALL BY REFERENCE

#include <stdio.h>void swap(int*, int*);int main(){ int x, y; printf("Enter the value of x and y\n"); scanf("%d%d",&x,&y); printf("Before Swapping\nx = %d\ny = %d\n", x, y); swap(&x, &y); printf("After Swapping\nx = %d\ny = %d\n", x, y); return 0;}

void swap(int *a, int *b){ int temp; temp = *b; *b = *a; *a = temp; }

FIBONACCI SERIES USING RECURSION

#include<stdio.h>int Fibonacci(int);main(){ int n, i = 0, c; scanf("%d",&n); printf("Fibonacci series\n"); for ( c = 1 ; c <= n ; c++ ) { printf("%d\n", Fibonacci(i)); i++; } return 0;}

int Fibonacci(int n){ if ( n == 0 ) return 0; else if ( n == 1 ) return 1; else return ( Fibonacci(n-1) +

Fibonacci(n-2) );}

THE END

User defined functions in C programmig

Education

Transcript of User defined functions in C programmig