Section 1 Functions: A function is a block of statements, which is used to perform a specific task. Suppose you are building an application in C language and in one of your program, you need to perform a same task more than once. So in such scenario you have two options a)Use the same set of statements every time you want to perform the task b)Create a function, which would do the task, and just call it every time you need to perform the same task. Using option (b) is a good practice and a good programmer always uses functions while writing codes. Benefits of Using Functions 1. It provides modularity to the program. 2. Easy code Reusability. You just have to call the function by its name to use it. 3. In case of large programs with thousands of code lines, debugging and editing becomes easier if you use functions. General syntax of function declaration is, return-type function-name (parameter-list); Like variable and an array, a function must also be declared before its called. 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 consist of 4 parts. return-type function name parameter list terminating semicolon General syntax of function definition is, return-type function-name (parameter-list) { function-body ; } The first line return-type function-name(parameter) is known as function header and the statement within curly braces is called function body. return-type : return type specifies the type of value(int,float,char,double) that function is expected to return to the program calling the function. function-name : function name specifies the name of the function. The function name is any valid C identifier and therefore must follow the same rule of formation as other variables in C. parameter-list : The parameter list declares the variables that will receive the data sent by calling program. They often referred to as formal parameters. These parameters are also used to send values to calling program. function-body: The function body contains the declarations and the statement(algorithm) necessary for performing the required task. The body is enclosed within curly braces { } and consists of three parts. local variable declaration. function statement that performs the tasks of the function. a return statement that return the value evaluated by the function.
Functions and Arguments
Arguments are the values specified during the function call, for which the formal parameters are declared in the function.
Example 1: Write a function that returns the larger of two input numbers along with the driver code. #include<stdio.h> int larger(int a,int b); // function declaration int main() /* main is called as driver code since it is not performing any computation*/ { int i,j,k; printf(enter two numbers); scanf(%d%d,&i,*j); k=larger(i,j); // function call printf("%d",k); return 0; } int larger(int a,int b){ // function declaration if(a>b) return a; else return b; } Lets try few more examples: Exercise 1: Write a function to find if a given number is prime or not. Function takes number as input argument. It returns 1 if number is prime else return 0. Based on the return value, print the appropriate message in main function.
Exercise 2: Write a program that takes the x-y coordinates of a point in the Cartesian plane. Write a function which takes as input the x-y coordinates and returns the quadrant in which it lies.
Section 2 Functions: Scope of data:
A scope in any programming is a region of the program where a defined variable can have its existence and beyond that variable it cannot be accessed. There are three places where variables can be declared in C programming language Inside a function or a block which is called local variables. Outside of all functions which is called global variables. In the definition of function parameters which are called formal parameters. Let us understand what are local and global variables, and formal parameters. int main () { /* local variable declaration */ int a, b; /* actual initialization */ a = 10; b = 20; g = a + b; printf ("value of a = %d, b = %d and g = %d\n", a, b, g); return 0; } A program can have same name for local and global variables but the value of local variable inside a function will take preference. Here is an example #include <stdio.h> /* global variable declaration */ int g = 20; int main () { /* local variable declaration */ int g = 10; printf ("value of g = %d\n", g); return 0; } When the above code is compiled and executed, it produces the following result value of g = 10 Formal Parameters Formal parameters, are treated as local variables with-in a function and they take precedence over global variables. Following is an example #include <stdio.h> /* global variable declaration */ int a = 20; int main () { /* local variable declaration in main function */ int a = 10; int b = 20; int c = 0; printf ("value of a in main() = %d\n", a); c = sum( a, b); printf ("value of c in main() = %d\n", c); return 0; } /* function to add two integers */ int sum(int a, int b) { printf ("value of a in sum() = %d\n", a); printf ("value of b in sum() = %d\n", b); return a + b; }
When the above code is compiled and executed, it produces the following result value of a in main() = 10 value of a in sum() = 10 value of b in sum() = 20 value of c in main() = 30 Initializing Local and Global Variables When a local variable is defined, it is not initialized by the system, you must initialize it yourself. Global variables are initialized automatically by the system when you define them as follows Data Type Initial Default Value int 0 char '\0' float 0 double 0 pointer NULL It is a good programming practice to initialize variables properly, otherwise your program may produce unexpected results, because uninitialized variables will take some garbage value already available at their memory location. Example 3: Write a function that finds the minimum of three numbers. The function then decrements this minimum number by one and increment other two numbers (by one). Pass three integers as input arguments to the function and return the decremented minimum number to main function. Print values of three integers from within the function, before and after calling the function in main. Emphasize on scope of variables and pass by value.
Exercise 43: Write a program for the following series. Divide the program into two functions as follows: (a) Write a power() function to compute 2a. This function takes variable 'a' as input argument and returns 2a. (b) Write a function to compute sum of series. This function takes 'N' as input argument and returns the sum of the series. power() function will be called in this function. Call this function in main().
Exercise 5: Calculate and print the value of 'i' using the following formula for different values of x and y: i = 2 + (y + 0.5x) Write a program, which will produce a table of values of i, y and x, where y varies from 1 to 6, and, for each value of y, x varies from 5.5 to 12.5 in steps of 0.5. Write a function for implementing the formula. Pass value of x and y as an input argument. Function returns the value of i. Call this function inside the nested loops for different values of x and y.
Exercise 6: Write a function that takes a character indicating a color as an input
argument and displays the full color if it is present else prints the message that the color is not present. Here function doesn't return anything. Emphasize on void return type. Rainbow colors: ROY G BIV = Red Orange Yellow Green Blue Indigo Voilet
Pointers are variables that hold address of another variable of same data type. Pointers are one of the most distinct and exciting features of C language. It provides power and flexibility to the language. Although pointer may appear little confusing and complicated in the beginning, but trust me its a powerful tool and handy to use once its mastered. Benefit of using pointers Pointers are more efficient in handling Array and Structure. Pointer allows references to function and thereby helps in passing of function as arguments to other function. It reduces length and the program execution time. It allows C to support dynamic memory management. Whenever a variable is declared, system will allocate a location to that variable in the memory, to hold value. This location will have its own address number. Let us assume that system has allocated memory location 80F (Hexa decimal representation of memory address) for a variable a. int a = 10 ;
We can access the value 10 by either using the variable name a or the address 80F. Since the memory addresses are simply numbers they can be assigned to some other variable. The variable that holds memory address are called pointer variables. A pointer variable is therefore nothing but a variable that contains an address, which is a location of another variable. Value of pointer variable will be stored in another memory location.
Declaring and initializing a pointer variable:
datatype * identifier ; int *a; The meaning of the above statement is that a is a pointer variable that holds address in which integer data is stored. Note: a itself is not an integer Example 1: declare a pointer variable that points to float data. float *f; Exercise 1: declare a pointer variable that points to character data. Exercise 2: What is the size of memory for a, f and c pointer variables? Unlike the variable the pointer variables also will have junk/garbage values. They have to be initialized before using. For example: int a=10; int *ptra; ptra=&a; //This statement assigns the pointer address where a is stored . *ptra=20; // This statement assign 20 to the memory location pointed by ptra Note: & is the address operator also called as reference operator and * is called as deference operator Pointers and functions: There are two ways of passing parameters to functions 1.pass by value 2.pass by reference Example 2: Demonstrate the implementation of call by value and reference for a program that swaps two input numbers. pass by value pass by reference #include<stdio.h> #include<stdio.h> void swap(int num1, int num2); void swap(int *num1, int int main() { *num2); int x, y; int main() { printf("\nEnter two int x, y; numbers : "); printf("\nEnter two scanf("%d%d",&x,&y); numbers : "); printf("\nBefore Swaping x = scanf("%d%d",&x,&y); %d and y = %d", x, y); printf("\nBefore Swaping x = swap(x, y); // Function Call %d and y = %d", x, y); - Pass By Reference swap(&x, &y); // Function printf("\nAfter Swaping x = Call - Pass By Reference %d and y = %d", x, y); printf("\nAfter Swaping x = return 0; %d and y = %d", x, y); } return 0; void swap(int num1, int num2) { } int temp; void swap(int *num1, int *num2) temp = num1; { num1 = num2; int temp; num2 = temp; temp = *num1; } *num1 = *num2;
Enter two numbers : 2 3
Before Swapping x = 2 and y = 3 After Swaping x = 2 and y = 3
*num2 = temp; } Enter two numbers : 2 3 Before Swapping x = 2 and y = 3 After Swaping x = 3 and y = 2
Conclusion from above example
1. When call by value is used a local copy of the variable is made in the function and the scope those variables are within the function. 2. When call by reference is used the address of the variables in the main are sent and the function has pointers refereeing to the sent address hence any change to the content pointed by pointers are permanent.
Section 2 Pointer Arithmetic:
A pointer in c is an address, which is a numeric value. Therefore, you can perform arithmetic operations on a pointer just as you can on a numeric value. There are four arithmetic operators that can be used on pointers: ++, --, +, and To understand pointer arithmetic, let us consider that ptr is an integer pointer which points to the address 1000. Assuming 32-bit integers, let us perform the following arithmetic operation on the pointer ptr++ After the above operation, the ptr will point to the location 1004 because each time ptr is incremented, it will point to the next integer location which is 4 bytes next to the current location. This operation will move the pointer to the next memory location without impacting the actual value at the memory location. The address computation is as follows when ptr++ is evaluated: ptr = ptr + 1 * sizeof(int) = 1000 + 1 * 4 = 1004 If ptr points to a character whose address is 1000, then the above operation will point to the location 1001 because the next character will be available at 1001. Example 3: Incrementing and decrementing a Pointer int arr[] = {10, 100, 1000}; int *ptr1,*ptr2; ptr1 = arr; /*here arr is an array and implicilty is a pointer hence & is ignored in case of arrays */ ptr1++; /*assuming that the starting address of the array is 1000 this step results in 1004 hence ptr now points to 1004*/ ptr1--; /*since the pointer was pointing to 1004 this step results in 1000 hence ptr now points to 1000*/ ptr2 = ptr1; //ptr2 will now point to 1000 memory location if(ptr1==ptr2) //Comparing two pointers printf(both pointers are pointing to the same location);
Section 3: Pointers and arrays
Arrays are closely related to pointers in C programming but the important difference between them is that, a pointer variable can take different addresses as value whereas, in case of array it is fixed. This is demonstrated by the following example: Example 4: #include <stdio.h> int main(){ char c[4]; int i; for(i=0;i<4;++i){ printf("Address of c[%d]=%x\n",i,&c[i]);
} return 0; } Address of c[0]=28ff44 Address of c[1]=28ff45 Address of c[2]=28ff46 Address of c[3]=28ff47 Notice, that there is equal difference (difference of 1 byte) between any two consecutive elements of array. Note: You may get different address of an array. Relation between Arrays and Pointers Consider and array: int arr[4]; Relation between arrays and pointers In arrays of C programming, name of the array always points to the first element of an array. Here, address of first element of an array is &arr[0]. Also, arr represents the address of the pointer where it is pointing. Hence, &arr[0] is equivalent to arr. Also, value inside the address &arr[0] and address arr are equal. Value in address &arr[0] is arr[0] and value in address arr is *arr. Hence, arr[0] is equivalent to *arr. Similarly, &a[1] is equivalent &a[2] is equivalent &a[3] is equivalent . . &a[i] is equivalent In C, you can declare an
to (a+1) to (a+2) to (a+1)
AND, a[1] is equivalent to *(a+1).
AND, a[2] is equivalent to *(a+2). AND, a[3] is equivalent to *(a+3).
to (a+i) AND, a[i] is equivalent to *(a+i).
array and can use pointer to alter the data of an array.
Example 5: Write a C program to find the sum of six numbers with arrays and pointers //Program to find the sum of six numbers with arrays and pointers. #include <stdio.h> int main(){ int i,class[6],sum=0; printf("Enter 6 numbers:\n"); for(i=0;i<6;++i){ scanf("%d",(class+i)); // (class+i) is equivalent to &class[i] sum += *(class+i); // *(class+i) is equivalent to class[i] } printf("Sum=%d",sum); return 0; } Output Enter 6 numbers: 2 3 4 5 3 4 Sum=21
Example 6: What is the output of the statements shown?
#include<stdio.h> int main() { int x[3][5]={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15}}, *n=&x[0][0]; printf("%d\n",*(*x)); printf("%d\n",*(*(x+2)+1)); printf("%d\n",*(*x+2)+5); printf("%d\n",(*(*(x+1)))); printf("%d\n",*(*(x+1)+3)); printf("%d\n",*(n+2)); printf("%d\n",(*(n+3)+1)); printf("%d\n",*(n+5)+1); printf("%d\n",++*n); } *(*x) = x has the base address hence it is *(*(x+0)+0) = 1 *(*(x+2)+1) = *(x+2) gets the address of the second row +1 means having the second row go to the second element = 12 *(*x+2)+5) = (*x+2) *x=base address of row 0 (*x+2*size) gives address of 0th row 2 nd col , *(*x+2) gives values at that address that is 3 *(*x+2)+5) = 3 + 5 = 8 (*(*(x+1)))) = *(x+1) = address of row 1 *(row1) = 6 *(*(x)+2)+1) = *(x) = *(x+0) = *((1+2)+1) = 4 *(*(x+1)+3) = x[1] [3] = 9 *(n+2) = *(base address + 2 * size of int) = 3 *(n+5)+1 = *(base address + 2 * size of int) = 6 + 1=7 ++ *n = *n=1 hence ++ gives 2 Exercise: Consider two arrays: x-coor[] and y-coor[]. The ith location of the two arrays stores the x and y coordinates of a point. For example, x-coor[4] and y-coor[4] stores the x and y coordinates of forth point. a) Pass these two arrays to a function which prints the quadrant in which each point lies. Emphasis is on passing array to a function. b) Pass these two arrays to a function. The function stores the quadrant in which each point lies in another array (which is also passed to the function). It then prints the quadrant in main function. Emphasis is on returning array from a function.
Exercise: Modularize the following program into multiple functions. Consider a list of prices of books represented as one dimensional array. Traverse the list and modify the prices according to the following conditions: (i) if price > 250, offer discount of 10%. Update the price with respect to discount. (ii) if price > 500, offer discount of 25%. Update the price w.r.t discount. Modularize it into following functions. (i) readList(): Populate prices of the items. (ii) printList(): Prints the price list. (iii) modifyList(): Modify the prices in the list according to the conditions given above. Identify input arguments and return types for all the functions. Also write main function where the functions are called.
Exercise: Implement insertion sort and bubble sort. First modularize the problem into separate functions by identifying arguments and return types. Now implement any one sorting technique.
