Unit 3

Arrays

3.1 Arrays (one and two dimensional)

One dimensional Array

A one-dimensional array is a group of elements having the same datatype and same name. Individual elements are referred to using common name and unique index of the elements.

The simplest form of an array is one-dimensional-array. The array itself is given name and its elements are referred to by their subscripts. In , an array is denoted as follows:

Array_name[array_size]

Where size specifies the number of elements in the array and the subscript (also called index) value ranges from 0 through size-1.

Declare One Dimensional Array

Here is the general form to declare one dimensional array in

Data_type array_name[array_size];

Here, data_type is any valid  data type, array_name is the name of the array, and array_size is the size of array. Here is an example, declaring an array named arr of int type, having maximum element size of 10 elements

Int arr[10];

Initialize One Dimensional Array

Here is the general form to initialize values to one dimensional array

Data_type array_name[array_size] = {comma_separated_element_list};

Here is an example, declaring and initializing values to the array name arr of type int, containing 10 elements

Int arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

One Dimensional Array Example

Here are some example programs, demonstrating one dimensional array

/*One Dimensional Array */

#include<iostream.h>

#include<conio.h>

Void main()

{

Clrscr();

Intarr[5] = {1, 2, 3, 4, 5};

Inti;

For(i=0; i<5; i++)

{

Cout<<"arr["<<i<<"] = "<<arr[i]<<"\n";

}

Getch();

}

Here is the sample output of this  program:

Here is another  example, also demonstrating one dimension array in

/*  One Dimensional Array */

#include<iostream.h>

#include<conio.h>

Void main()

{

Clrscr();

Intarr[10];

Inti;

Int sum=0, avg=0;

Cout<<"Enter 10 array elements: ";

For(i=0; i<10; i++)

{

Cin>>arr[i];

Sum = sum + arr[i];

}

Cout<<"\nThe array elements are: \n";

For(i=0; i<10; i++)

{

Cout<<arr[i]<<"  ";

}

Cout<<"\n\nSum of all elements is: "<<sum;

Avg = sum/10;

Cout<<"\nAnd average is: "<<avg;

Getch();

}

Here is the sample run of the above  program:

Below is another program on one-dimensional array in

/*  One Dimensional Array */

#include<iostream.h>

#include<conio.h>

Void main()

{

Clrscr();

Intarr[5];

Inti, position, index;

Cout<<"Enter 5 array elements: ";

For(i=0; i<5; i++)

{

Cin>>arr[i];

}

Cout<<"\nIndex\t\tPosition";

For(i=0; i<5; i++)

{

Cout<<"\n";

Cout<<i<<" = "<<arr[i]<<"\t\t"<<i+1<<" = "<<arr[i+1];

}

Cout<<" (Garbage value/not of array)";

Cout<<"\n\nImportant - Array element can only be accessed by indexing the array\n";

Cout<<"Note - Array index always starts from 0";

Getch();

}

Below is the sample run of this  program:

Let's take one more  program, on single or one dimensional array

/*  One Dimensional Array */

#include<iostream.h>

#include<conio.h>

Void main()

{

Clrscr();

Intarr[10];

Inti, position, index;

Cout<<"Enter 10 array elements: ";

For(i=0; i<10; i++)

{

Cin>>arr[i];

}

Cout<<"Accessing element at position...Enter position...";

Cin>>position;

Cout<<"\nElement present at position "<<position<<" is "<<arr[position+1];

Cout<<"\n\nAccessing element at index..Enter index..";

Cin>>index;

Cout<<"\nElement present at index "<<index<<" is "<<arr[index];

Getch();

}

Here is the sample run of the above  program:

Two Dimensional Array

The two-dimensional array can be defined as an array of arrays. The 2D array is organized as matrices which can be represented as the collection of rows and columns. However, 2D arrays are created to implement a relational database lookalike data structure. It provides ease of holding the bulk of data at once which can be passed to any number of functions wherever required.

Declaration of two dimensional Array in C

The syntax to declare the 2D array is given below.

1. Data_type array_name[rows][columns];  

Consider the following example.

1. Int twodimen[4][3];  

Here, 4 is the number of rows, and 3 is the number of columns.

Initialization of 2D Array in C

In the 1D array, we don't need to specify the size of the array if the declaration and initialization are being done simultaneously. However, this will not work with 2D arrays. We will have to define at least the second dimension of the array. The two-dimensional array can be declared and defined in the following way.

1. Int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};  

Two-dimensional array example in C

1. #include<stdio.h>  
2. Int main(){      
3. Int i=0,j=0;    
4. Int arr[4][3]={{1,2,3},{2,3,4},{3,4,5},{4,5,6}};     
5. //traversing 2D array    
6. For(i=0;i<4;i++){    
7. For(j=0;j<3;j++){    
8.   Printf("arr[%d] [%d] = %d \n",i,j,arr[i][j]);    
9. }//end of j    
10. }//end of i    
11. Return 0;  
12. }    

Output

Arr[0][0] = 1

Arr[0][1] = 2

Arr[0][2] = 3

Arr[1][0] = 2

Arr[1][1] = 3

Arr[1][2] = 4

Arr[2][0] = 3

Arr[2][1] = 4

Arr[2][2] = 5

Arr[3][0] = 4

Arr[3][1] = 5

Arr[3][2] = 6

C 2D array example: Storing elements in a matrix and printing it.

1. #include <stdio.h>    
2. Void main ()    
3. {    
4.    Int arr[3][3],i,j;     
5.    For (i=0;i<3;i++)    
6.    {    
7.        For (j=0;j<3;j++)    
8.        {    
9.            Printf("Enter a[%d][%d]: ",i,j);                
10.            Scanf("%d",&arr[i][j]);    
11.        }    
12.    }    
13.    Printf("\n printing the elements ....\n");     
14.    For(i=0;i<3;i++)    
15.    {    
16.        Printf("\n");    
17.        For (j=0;j<3;j++)    
18.        {    
19.            Printf("%d\t",arr[i][j]);    
20.        }    
21.    }    
22. }    

Output

Enter a[0][0]: 56  

Enter a[0][1]: 10  

Enter a[0][2]: 30 

Enter a[1][0]: 34 

Enter a[1][1]: 21

Enter a[1][2]: 34   

Enter a[2][0]: 45

Enter a[2][1]: 56

Enter a[2][2]: 78  

Printing the elements ....

56      10      30 

34      21      34 

45       56      78

3.2 2-d arrays used in matrix computation

Program to Add Two Matrices

#include<stdio.h>

Intmain(){

Int r, c, a[100][100], b[100][100], sum[100][100], i, j;

Printf("Enter the number of rows (between 1 and 100): ");

Scanf("%d", &r);

Printf("Enter the number of columns (between 1 and 100): ");

Scanf("%d", &c);

Printf("\nEnter elements of 1st matrix:\n");

For (i = 0; i< r; ++i)

For (j = 0; j < c; ++j) {

Printf("Enter element a%d%d: ", i + 1, j + 1);

Scanf("%d", &a[i][j]);

}

Printf("Enter elements of 2nd matrix:\n");

For (i = 0; i< r; ++i)

For (j = 0; j < c; ++j) {

Printf("Enter element a%d%d: ", i + 1, j + 1);

Scanf("%d", &b[i][j]);

}

// adding two matrices

For (i = 0; i< r; ++i)

For (j = 0; j < c; ++j) {

Sum[i][j] = a[i][j] + b[i][j];

}

// printing the result

Printf("\nSum of two matrices: \n");

For (i = 0; i< r; ++i)

For (j = 0; j < c; ++j) {

Printf("%d   ", sum[i][j]);

If (j == c - 1) {

Printf("\n\n");

}

}

Return0;

}

Output

Enter the number of rows (between 1 and 100): 2

Enter the number of columns (between 1 and 100): 3

Enter elements of 1st matrix:

Enter element a11: 2

Enter element a12: 3

Enter element a13: 4

Enter element a21: 5

Enter element a22: 2

Enter element a23: 3

Enter elements of 2nd matrix:

Enter element a11: -4

Enter element a12: 5

Enter element a13: 3

Enter element a21: 5

Enter element a22: 6

Enter element a23: 3

Sum of two matrices:

-2   8   7  

10   8   6 

In this program, the user is asked to enter the number of rows r and columns c. Then, the user is asked to enter the elements of the two matrices (of order r*c).

We then added corresponding elements of two matrices and saved it in another matrix (two-dimensional array). Finally, the result is printed on the screen.

3.3 Concept of Sub-programming

A Subprogram is a program inside any larger program that can be reused any number of times.

Characteristics of a Subprogram:

(1) A Subprogram is implemented using the Call & Return instructions in Assembly Language.

(2) The Call Instruction is present in the Main Program and the Return(Ret) Instruction is present in the subprogram itself.

(3) It is important to note that the Main Program is suspended during the execution of any subprogram. Moreover, after the completion of the subprogram the main program executes from the next sequential address present in the Program Counter.

(4) For the implementation of any subprogram, a “Stack” is used to store the “Return Address” to the Main Program. Here, Return Address means the immediately next instruction address after the Call Instruction in the Main program. This Return Address is present inside the Program Counter. Thus during the execution of the Call Instruction, the Program Counter value is first pushed to the Stack as the Return Address and then the Program Counter value is updated to the given address in the Call Instruction . Similarly, during the execution of Return(Ret) Instruction, the value present in the stack is popped and the Program Counter value is restored for further execution of the Main Program .

(5) The Main advantage of Subprogram is that it avoids repetition of Code and allows us to reuse the same code again and again.

3.4 Functions

In c, we can divide a large program into the basic building blocks known as function. The function contains the set of programming statements enclosed by {}. A function can be called multiple times to provide reusability and modularity to the C program. In other words, we can say that the collection of functions creates a program. The function is also known as procedure or subroutine in other programming languages.

Advantage of functions in C

There are the following advantages of C functions.

• By using functions, we can avoid rewriting same logic/code again and again in a program.
• We can call C functions any number of times in a program and from any place in a program.
• We can track a large C program easily when it is divided into multiple functions.
• Reusability is the main achievement of C functions.
• However, Function calling is always a overhead in a C program.

Function Aspects

There are three aspects of a C function.

• Function declarationA function must be declared globally in a c program to tell the compiler about the function name, function parameters, and return type.

• Function call Function can be called from anywhere in the program. The parameter list must not differ in function calling and function declaration. We must pass the same number of functions as it is declared in the function declaration.

• Function definition It contains the actual statements which are to be executed. It is the most important aspect to which the control comes when the function is called. Here, we must notice that only one value can be returned from the function.

The syntax of creating function in c language is given below:

1. Return_type function_name(data_type parameter...){  
2. //code to be executed  
3. }  

Types of Functions

There are two types of functions in C programming:

1. Library Functions: are the functions which are declared in the C header files such as scanf(), printf(), gets(), puts(), ceil(), floor() etc.
2. User-defined functions: are the functions which are created by the C programmer, so that he/she can use it many times. It reduces the complexity of a big program and optimizes the code.

Return Value

A C function may or may not return a value from the function. If you don't have to return any value from the function, use void for the return type.

Let's see a simple example of C function that doesn't return any value from the function.

Example without return value:

1. Void hello(){  
2. Printf("hello c");  
3. }  

If you want to return any value from the function, you need to use any data type such as int, long, char, etc. The return type depends on the value to be returned from the function.

Let's see a simple example of C function that returns int value from the function.

Example with return value:

1. Int get(){  
2. Return 10;  
3. }  

In the above example, we have to return 10 as a value, so the return type is int. If you want to return floating-point value (e.g., 10.2, 3.1, 54.5, etc), you need to use float as the return type of the method.

1. Float get(){  
2. Return 10.2;  
3. }  

Now, you need to call the function, to get the value of the function.

Different aspects of function calling

A function may or may not accept any argument. It may or may not return any value. Based on these facts, There are four different aspects of function calls.

• Function without arguments and without return value
• Function without arguments and with return value
• Function with arguments and without return value
• Function with arguments and with return value

Example for Function without argument and return value

Example 1

1. #include<stdio.h>  
2. Void printName();  
3. Void main ()  
4. {  
5.    Printf("Hello ");  
6.    PrintName();  
7. }  
8. Void printName()  
9. {  
10.    Printf("Javatpoint");  
11. }  

Output

Hello Javatpoint

Example 2

1. #include<stdio.h>  
2. Void sum();  
3. Void main()  
4. {  
5.    Printf("\nGoing to calculate the sum of two numbers:");  
6.    Sum();  
7. }  
8. Void sum()  
9. {  
10.    Int a,b;   
11.    Printf("\nEnter two numbers");  
12.    Scanf("%d %d",&a,&b);   
13.    Printf("The sum is %d",a+b);  
14. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example for Function without argument and with return value

Example 1

1. #include<stdio.h>  
2. Int sum();  
3. Void main()  
4. {  
5.    Int result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Result = sum();  
8.    Printf("%d",result);  
9. }  
10. Int sum()  
11. {  
12.    Int a,b;   
13.    Printf("\nEnter two numbers");  
14.    Scanf("%d %d",&a,&b);  
15.    Return a+b;   
16. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example 2: program to calculate the area of the square

1. #include<stdio.h>  
2. Int sum();  
3. Void main()  
4. {  
5.    Printf("Going to calculate the area of the square\n");  
6.    Float area = square();  
7.    Printf("The area of the square: %f\n",area);  
8. }  
9. Int square()  
10. {  
11.    Float side;  
12.    Printf("Enter the length of the side in meters: ");  
13.    Scanf("%f",&side);  
14.    Return side * side;  
15. }  

Output

Going to calculate the area of the square

Enter the length of the side in meters: 10

The area of the square: 100.000000

Example for Function with argument and without return value

Example 1

1. #include<stdio.h>  
2. Void sum(int, int);  
3. Void main()  
4. {  
5.    Int a,b,result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Printf("\nEnter two numbers:");  
8.    Scanf("%d %d",&a,&b);  
9.    Sum(a,b);  
10. }  
11. Void sum(int a, int b)  
12. {  
13.    Printf("\nThe sum is %d",a+b);      
14. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10

24

The sum is 34

Example 2: program to calculate the average of five numbers.

1. #include<stdio.h>  
2. Void average(int, int, int, int, int);  
3. Void main()  
4. {  
5.    Int a,b,c,d,e;   
6.    Printf("\nGoing to calculate the average of five numbers:");  
7.    Printf("\nEnter five numbers:");  
8.    Scanf("%d %d %d %d %d",&a,&b,&c,&d,&e);  
9.    Average(a,b,c,d,e);  
10. }  
11. Void average(int a, int b, int c, int d, int e)  
12. {  
13.    Float avg;   
14.    Avg = (a+b+c+d+e)/5;   
15.    Printf("The average of given five numbers : %f",avg);  
16. }  

Output

Going to calculate the average of five numbers:

Enter five numbers:10

20

30

40

50

The average of given five numbers: 30.000000

Example for Function with argument and with return value

Example 1

1. #include<stdio.h>  
2. Int sum(int, int);  
3. Void main()  
4. {  
5.    Int a,b,result;   
6.    Printf("\nGoing to calculate the sum of two numbers:");  
7.    Printf("\nEnter two numbers:");  
8.    Scanf("%d %d",&a,&b);  
9.    Result = sum(a,b);  
10.    Printf("\nThe sum is : %d",result);  
11. }  
12. Int sum(int a, int b)  
13. {  
14.    Return a+b;  
15. }  

Output

Going to calculate the sum of two numbers:

Enter two numbers:10

20

The sum is : 30  

Example 2: Program to check whether a number is even or odd

1. #include<stdio.h>  
2. Int even_odd(int);  
3. Void main()  
4. {  
5. Int n,flag=0;  
6. Printf("\nGoing to check whether a number is even or odd");  
7. Printf("\nEnter the number: ");  
8. Scanf("%d",&n);  
9. Flag = even_odd(n);  
10. If(flag == 0)  
11. {  
12.    Printf("\nThe number is odd");  
13. }  
14. Else   
15. {  
16.    Printf("\nThe number is even");  
17. }  
18. }  
19. Int even_odd(int n)  
20. {  
21.    If(n%2 == 0)  
22.    {  
23.        Return 1;  
24.    }  
25.    Else   
26.    {  
27.        Return 0;  
28.    }  
29. }  

Output

Going to check whether a number is even or odd

Enter the number: 100

The number is even

C Library Functions

Library functions are the inbuilt function in C that are grouped and placed at a common place called the library. Such functions are used to perform some specific operations. For example, printf is a library function used to print on the console. The library functions are created by the designers of compilers. All C standard library functions are defined inside the different header files saved with the extension .h. We need to include these header files in our program to make use of the library functions defined in such header files. For example, To use the library functions such as printf/scanf we need to include stdio.h in our program which is a header file that contains all the library functions regarding standard input/output.

The list of mostly used header files is given in the following table.

3.5 Parameter transmission schemes i.e. call by value and call by reference

There are two methods to pass the data into the function in C language, i.e., call by value and call by reference.

Let's understand call by value and call by reference in c language one by one.

Call by value in C

• In call by value method, the value of the actual parameters is copied into the formal parameters. In other words, we can say that the value of the variable is used in the function call in the call by value method.
• In call by value method, we can not modify the value of the actual parameter by the formal parameter.
• In call by value, different memory is allocated for actual and formal parameters since the value of the actual parameter is copied into the formal parameter.
• The actual parameter is the argument which is used in the function call whereas formal parameter is the argument which is used in the function definition.

Let's try to understand the concept of call by value in c language by the example given below:

1. #include<stdio.h>  
2. Void change(int num) {    
3.    Printf("Before adding value inside function num=%d \n",num);    
4.    Num=num+100;    
5.    Printf("After adding value inside function num=%d \n", num);    
6. }    
7. Int main() {    
8.    Int x=100;    
9.    Printf("Before function call x=%d \n", x);    
10.    Change(x);//passing value in function    
11.    Printf("After function call x=%d \n", x);    
12. Return 0;  
13. }    

Output

Before function call x=100

Before adding value inside function num=100

After adding value inside function num=200

After function call x=100

Call by Value Example: Swapping the values of the two variables

1. #include <stdio.h>  
2. Void swap(int , int); //prototype of the function   
3. Int main()  
4. {  
5.    Int a = 10;  
6.    Int b = 20;   
7.    Printf("Before swapping the values in main a = %d, b = %d\n",a,b); // printing the value of a and b in main  
8.    Swap(a,b);  
9.    Printf("After swapping values in main a = %d, b = %d\n",a,b); // The value of actual parameters do not change by changing the formal parameters in call by value, a = 10, b = 20  
10. }  
11. Void swap (int a, int b)  
12. {  
13.    Int temp;   
14.    Temp = a;  
15.    a=b;  
16.    b=temp;  
17.    Printf("After swapping values in function a = %d, b = %d\n",a,b); // Formal parameters, a = 20, b = 10   
18. }  

Output

Before swapping the values in main a = 10, b = 20

After swapping values in function a = 20, b = 10

After swapping values in main a = 10, b = 20 

Call by reference in C

• In call by reference, the address of the variable is passed into the function call as the actual parameter.
• The value of the actual parameters can be modified by changing the formal parameters since the address of the actual parameters is passed.
• In call by reference, the memory allocation is similar for both formal parameters and actual parameters. All the operations in the function are performed on the value stored at the address of the actual parameters, and the modified value gets stored at the same address.

Consider the following example for the call by reference.

1. #include<stdio.h>  
2. Void change(int *num) {    
3.    Printf("Before adding value inside function num=%d \n",*num);    
4.    (*num) += 100;    
5.    Printf("After adding value inside function num=%d \n", *num);    
6. }      
7. Int main() {    
8.    Int x=100;    
9.    Printf("Before function call x=%d \n", x);    
10.    Change(&x);//passing reference in function    
11.    Printf("After function call x=%d \n", x);    
12. Return 0;  
13. }    

Output

Before function call x=100

Before adding value inside function num=100

After adding value inside function num=200

After function call x=200

Call by reference Example: Swapping the values of the two variables

1. #include <stdio.h>  
2. Void swap(int *, int *); //prototype of the function   
3. Int main()  
4. {  
5.    Int a = 10;  
6.    Int b = 20;   
7.    Printf("Before swapping the values in main a = %d, b = %d\n",a,b); // printing the value of a and b in main  
8.    Swap(&a,&b);  
9.    Printf("After swapping values in main a = %d, b = %d\n",a,b); // The values of actual parameters do change in call by reference, a = 10, b = 20  
10. }  
11. Void swap (int *a, int *b)  
12. {  
13.    Int temp;   
14.    Temp = *a;  
15.    *a=*b;  
16.    *b=temp;  
17.    Printf("After swapping values in function a = %d, b = %d\n",*a,*b); // Formal parameters, a = 20, b = 10   
18. }  

Output

Before swapping the values in main a = 10, b = 20

After swapping values in function a = 20, b = 10

After swapping values in main a = 20, b = 10 

Difference between call by value and call by reference in c

3.6 Pointers

The pointer in C language is a variable which stores the address of another variable. This variable can be of type int, char, array, function, or any other pointer. The size of the pointer depends on the architecture. However, in 32-bit architecture the size of a pointer is 2 byte.

Consider the following example to define a pointer which stores the address of an integer.

1. Int n = 10;   
2. Int* p = &n; // Variable p of type pointer is pointing to the address of the variable n of type integer.   

Declaring a pointer

The pointer in c language can be declared using * (asterisk symbol). It is also known as indirection pointer used to dereference a pointer.

1. Int *a;//pointer to int  
2. Char *c;//pointer to char  

Pointer Example

An example of using pointers to print the address and value is given below.

As you can see in the above figure, pointer variable stores the address of number variable, i.e., fff4. The value of number variable is 50. But the address of pointer variable p is aaa3.

By the help of * (indirection operator), we can print the value of pointer variable p.

Let's see the pointer example as explained for the above figure.

1. #include<stdio.h>  
2. Int main(){  
3. Int number=50;    
4. Int *p;      
5. p=&number;//stores the address of number variable    
6. Printf("Address of p variable is %x \n",p); // p contains the address of the number therefore printing p gives the address of number.     
7. Printf("Value of p variable is %d \n",*p); // As we know that * is used to dereference a pointer therefore if we print *p, we will get the value stored at the address contained by p.    
8. Return 0;  
9. }    

Output

Address of number variable is fff4

Address of p variable is fff4

Value of p variable is 50

Pointer to array

1. Int arr[10];  
2. Int *p[10]=&arr; // Variable p of type pointer is pointing to the address of an integer array arr.  

Pointer to a function

1. Void show (int);  
2. Void(*p)(int) = &display; // Pointer p is pointing to the address of a function  

Pointer to structure

1. Struct st {  
2.    Int i;  
3.    Float f;  
4. }ref;  
5. Struct st *p = &ref;  

Advantage of pointer

1) Pointer reduces the code and improves the performance, it is used to retrieving strings, trees, etc. and used with arrays, structures, and functions.

2) We can return multiple values from a function using the pointer.

3) It makes you able to access any memory location in the computer's memory.

Usage of pointer

There are many applications of pointers in c language.

1) Dynamic memory allocation

In c language, we can dynamically allocate memory using malloc() and calloc() functions where the pointer is used.

2) Arrays, Functions, and Structures

Pointers in c language are widely used in arrays, functions, and structures. It reduces the code and improves the performance.

Address Of (&) Operator

The address of operator '&' returns the address of a variable. But, we need to use %u to display the address of a variable.

1. #include<stdio.h>  
2. Int main(){  
3. Int number=50;   
4. Printf("value of number is %d, address of number is %u",number,&number);    
5. Return 0;  
6. }    

Output

Value of number is 50, address of number is fff4

NULL Pointer

A pointer that is not assigned any value but NULL is known as the NULL pointer. If you don't have any address to be specified in the pointer at the time of declaration, you can assign NULL value. It will provide a better approach.

Int *p=NULL;

In the most libraries, the value of the pointer is 0 (zero).

Pointer Program to swap two numbers without using the 3rd variable.

1. #include<stdio.h>  
2. Int main(){  
3. Int a=10,b=20,*p1=&a,*p2=&b;  
4.  
5. Printf("Before swap: *p1=%d *p2=%d",*p1,*p2);  
6. *p1=*p1+*p2;  
7. *p2=*p1-*p2;  
8. *p1=*p1-*p2;  
9. Printf("\nAfter swap: *p1=%d *p2=%d",*p1,*p2);  
10.  
11. Return 0;  
12. }  

Output

Before swap: *p1=10 *p2=20

After swap: *p1=20 *p2=10

Reading complex pointers

There are several things which must be taken into the consideration while reading the complex pointers in C. Lets see the precedence and associativity of the operators which are used regarding pointers.

Here,we must notice that,

• (): This operator is a bracket operator used to declare and define the function.
• []: This operator is an array subscript operator
• * : This operator is a pointer operator.
• Identifier: It is the name of the pointer. The priority will always be assigned to this.
• Data type: Data type is the type of the variable to which the pointer is intended to point. It also includes the modifier like signed int, long, etc).

How to read the pointer: int (*p)[10].

To read the pointer, we must see that () and [] have the equal precedence. Therefore, their associativity must be considered here. The associativity is left to right, so the priority goes to ().

Inside the bracket (), pointer operator * and pointer name (identifier) p have the same precedence. Therefore, their associativity must be considered here which is right to left, so the priority goes to p, and the second priority goes to *.

Assign the 3rd priority to [] since the data type has the last precedence. Therefore the pointer will look like following.

• Char -> 4
• * -> 2
• p -> 1
• [10] -> 3

The pointer will be read as p is a pointer to an array of integers of size 10.

Example

How to read the following pointer?

1. Int (*p)(int (*)[2], int (*)void))  

Explanation

This pointer will be read as p is a pointer to such function which accepts the first parameter as the pointer to a one-dimensional array of integers of size two and the second parameter as the pointer to a function which parameter is void and return type is the integer.

3.7 Relationship between Array and Pointer

Relationship between Arrays and Pointers

An array is a block of sequential data. Let's write a program to print addresses of array elements.

#include<stdio.h>

Intmain(){

Int x[4];

Inti;

For(i = 0; i<4; ++i) {

Printf("&x[%d] = %p\n", i, &x[i]);

}

Printf("Address of array x: %p", x);

Return0;

}

Output

&x[0] = 1450734448

&x[1] = 1450734452

&x[2] = 1450734456

&x[3] = 1450734460

Address of array x: 1450734448

There is a difference of 4 bytes between two consecutive elements of array x. It is because the size of int is 4 bytes (on our compiler).

Notice that, the address of &x[0] and x is the same. It's because the variable name x points to the first element of the array.

From the above example, it is clear that &x[0] is equivalent to x. And, x[0] is equivalent to *x.

Similarly,

• &x[1] is equivalent to x+1 and x[1] is equivalent to *(x+1).
• &x[2] is equivalent to x+2 and x[2] is equivalent to *(x+2).
• ...
• Basically, &x[i] is equivalent to x+i and x[i] is equivalent to *(x+i).

Example 1: Pointers and Arrays

#include<stdio.h>

Intmain(){

Inti, x[6], sum = 0;

Printf("Enter 6 numbers: ");

For(i = 0; i<6; ++i) {

// Equivalent to scanf("%d", &x[i]);

Scanf("%d", x+i);

// Equivalent to sum += x[i]

Sum += *(x+i);

}

Printf("Sum = %d", sum);

Return0;

}

When you run the program, the output will be:

Enter 6 numbers:  2

3

4

4

12

4

Sum = 29

Here, we have declared an array x of 6 elements. To access elements of the array, we have used pointers.

In most contexts, array names decay to pointers. In simple words, array names are converted to pointers. That's the reason why you can use pointers to access elements of arrays. However, you should remember that pointers and arrays are not the same.

There are a few cases where array names don't decay to pointers.

Example 2: Arrays and Pointers

#include<stdio.h>

Intmain(){

Int x[5] = {1, 2, 3, 4, 5};

Int* ptr;

// ptr is assigned the address of the third element

Ptr = &x[2];

Printf("*ptr = %d \n", *ptr);   // 3

Printf("*(ptr+1) = %d \n", *(ptr+1)); // 4

Printf("*(ptr-1) = %d", *(ptr-1));  // 2

Return0;

}

When you run the program, the output will be:

*ptr = 3

*(ptr+1) = 4

*(ptr-1) = 2

In this example, &x[2], the address of the third element, is assigned to the ptr pointer. Hence, 3 was displayed when we printed *ptr.

And, printing *(ptr+1) gives us the fourth element. Similarly, printing *(ptr-1) gives us the second element.

3.8 Argument passing using pointers

C programming allows passing a pointer to a function. To do so, simply declare the function parameter as a pointer type.

Following is a simple example where we pass an unsigned long pointer to a function and change the value inside the function which reflects back in the calling function −

#include <stdio.h>

#include <time.h>

VoidgetSeconds(unsigned long *par);

Int main () {

Unsigned long sec;

GetSeconds(&sec );

/* print the actual value */

Printf("Number of seconds: %ld\n", sec );

Return 0;

}

VoidgetSeconds(unsigned long *par) {

/* get the current number of seconds */

*par = time( NULL );

Return;

}

When the above code is compiled and executed, it produces the following result −

Number of seconds :1294450468

The function, which can accept a pointer, can also accept an array as shown in the following example −

#include <stdio.h>

/* function declaration */

DoublegetAverage(int *arr, int size);

Int main () {

/* an int array with 5 elements */

Int balance[5] = {1000, 2, 3, 17, 50};

Doubleavg;

/* pass pointer to the array as an argument */

Avg = getAverage( balance, 5 ) ;

/* output the returned value  */

Printf("Average value is: %f\n", avg );

Return 0;

}

DoublegetAverage(int *arr, int size) {

Inti, sum = 0;      

Doubleavg;         

For (i = 0; i< size; ++i) {

Sum += arr[i];

}

Avg = (double)sum / size;

Returnavg;

}

When the above code is compiled together and executed, it produces the following result −

Average value is: 214.40000

3.9 Array of pointer

Array and pointers are closely related to each other. In C++, the name of an array is considered às a pointer, i.e., the name of an array contains the address of an element. C++ considers the array name as the address of the first element. For example, if we create an array, i.e., marks which hold the 20 values of integer type, then marks will contain the address of first element, i.e., marks[0]. Therefore, we can say that array name (marks) is a pointer which is holding the address of the first element of an array.

Let's understand this scenario through an example.

1. #include <iostream>  
2. Using namespace std;  
3. Int main()  
4. {  
5.    Int *ptr;  // integer pointer declaration  
6.    Int marks[10]; // marks array declaration  
7.    Std::cout << "Enter the elements of an array :" << std::endl;  
8.    For(int i=0;i<10;i++)  
9.    {  
10.        Cin>>marks[i];  
11.    }  
12.    Ptr=marks; // both marks and ptr pointing to the same element..  
13.    Std::cout << "The value of *ptr is :" <<*ptr<< std::endl;  
14.    Std::cout << "The value of *marks is :" <<*marks<<std::endl;  
15. }  

In the above code, we declare an integer pointer and an array of integer type. We assign the address of marks to the ptr by using the statement ptr=marks; it means that both the variables 'marks' and 'ptr' point to the same element, i.e., marks[0]. When we try to print the values of *ptr and *marks, then it comes out to be same. Hence, it is proved that the array name stores the address of the first element of an array.

Output

Array of Pointers

An array of pointers is an array that consists of variables of pointer type, which means that the variable is a pointer addressing to some other element. Suppose we create an array of pointer holding 5 integer pointers; then its declaration would look like:

1. Int *ptr[5];         // array of 5 integer pointer.   

In the above declaration, we declare an array of pointer named as ptr, and it allocates 5 integer pointers in memory.

The element of an array of a pointer can also be initialized by assigning the address of some other element. Let's observe this case through an example.

1. Int a; // variable declaration.  
2. Ptr[2] = &a;    

In the above code, we are assigning the address of 'a' variable to the third element of an array 'ptr'.

We can also retrieve the value of 'a' be dereferencing the pointer.

1. *ptr[2];  

Let's understand through an example.

1. #include <iostream>  
2. Using namespace std;  
3. Int main()  
4. {  
5.    Int ptr1[5]; // integer array declaration  
6.    Int *ptr2[5]; // integer array of pointer declaration  
7.    Std::cout << "Enter five numbers :" << std::endl;  
8.    For(int i=0;i<5;i++)  
9.    {  
10.        Std::cin >> ptr1[i];  
11.    }  
12.    For(int i=0;i<5;i++)  
13.    {  
14.        Ptr2[i]=&ptr1[i];   
15.    }  
16.    // printing the values of ptr1 array  
17.    Std::cout << "The values are" << std::endl;  
18.    For(int i=0;i<5;i++)  
19.    {  
20.        Std::cout << *ptr2[i] << std::endl;  
21.    }  
22.    }  

In the above code, we declare an array of integer type and an array of integer pointers. We have defined the 'for' loop, which iterates through the elements of an array 'ptr1', and on each iteration, the address of element of ptr1 at index 'i' gets stored in the ptr2 at index 'i'.

Output

Till now, we have learnt the array of pointers to an integer. Now, we will see how to create the array of pointers to strings.

Array of Pointer to Strings

An array of pointer to strings is an array of character pointers that holds the address of the first character of a string or we can say the base address of a string.

The following are the differences between an array of pointers to string and two-dimensional array of characters:

• An array of pointers to string is more efficient than the two-dimensional array of characters in case of memory consumption because an array of pointer to strings consumes less memory than the two-dimensional array of characters to store the strings.
• In an array of pointers, the manipulation of strings is comparatively easier than in the case of 2d array. We can also easily change the position of the strings by using the pointers.

Let's see how to declare the array of pointers to string.

First, we declare the array of pointer to string:

1. Char *names[5] = {"john",  
2.                  "Peter",  
3.                  "Marco",  
4.                  "Devin",  
5.                  "Ronan"};  

In the above code, we declared an array of pointer names as 'names' of size 5. In the above case, we have done the initialization at the time of declaration, so we do not need to mention the size of the array of a pointer. The above code can be re-written as:

1. Char *names[ ] = {"john",  
2.                  "Peter",  
3.                  "Marco",  
4.                  "Devin",  
5.                  "Ronan"};  

In the above case, each element of the 'names' array is a string literal, and each string literal would hold the base address of the first character of a string. For example, names[0] contains the base address of "john", names[1] contains the base address of "Peter", and so on. It is not guaranteed that all the string literals will be stored in the contiguous memory location, but the characters of a string literal are stored in a contiguous memory location.

Let's create a simple example.

1. #include <iostream>  
2. Using namespace std;  
3. Int main()  
4. {  
5.  Char *names[5] = {"john",  
6.                    "Peter",  
7.                    "Marco",  
8.                    "Devin",  
9.                    "Ronan"};  
10. For(int i=0;i<5;i++)  
11.    {  
12.        Std::cout << names[i] << std::endl;  
13.    }  
14.    Return 0;  
15. }  

In the above code, we have declared an array of char pointer holding 5 string literals, and the first character of each string is holding the base address of the string.

Output

3.10 Passing Arrays as Arguments

In C, there are various general problems which requires passing more than one variable of the same type to a function. For example, consider a function which sorts the 10 elements in ascending order. Such a function requires 10 numbers to be passed as the actual parameters from the main function. Here, instead of declaring 10 different numbers and then passing into the function, we can declare and initialize an array and pass that into the function. This will resolve all the complexity since the function will now work for any number of values.

As we know that the array_name contains the address of the first element. Here, we must notice that we need to pass only the name of the array in the function which is intended to accept an array. The array defined as the formal parameter will automatically refer to the array specified by the array name defined as an actual parameter.

Consider the following syntax to pass an array to the function.

1. Functionname(arrayname);//passing array  

Methods to declare a function that receives an array as an argument

There are 3 ways to declare the function which is intended to receive an array as an argument.

First way:

1. Return_type function(type arrayname[])  

Declaring blank subscript notation [] is the widely used technique.

Second way:

1. Return_type function(type arrayname[SIZE])  

Optionally, we can define size in subscript notation [].

Third way:

1. Return_type function(type *arrayname)  

You can also use the concept of a pointer. In pointer chapter, we will learn about it.

C language passing an array to function example

1. #include<stdio.h>  
2. Int minarray(int arr[],int size){    
3. Int min=arr[0];    
4. Int i=0;    
5. For(i=1;i<size;i++){    
6. If(min>arr[i]){    
7. Min=arr[i];    
8. }    
9. }//end of for    
10. Return min;    
11. }//end of function    
12.    
13. Int main(){      
14. Int i=0,min=0;    
15. Int numbers[]={4,5,7,3,8,9};//declaration of array    
16.  
17. Min=minarray(numbers,6);//passing array with size    
18. Printf("minimum number is %d \n",min);    
19. Return 0;  
20. }    

Output

Minimum number is 3

C function to sort the array

1. #include<stdio.h>   
2. Void Bubble_Sort(int[]);  
3. Void main ()    
4. {    
5.    Int arr[10] = { 10, 9, 7, 101, 23, 44, 12, 78, 34, 23};     
6.    Bubble_Sort(arr);    
7. }    
8. Void Bubble_Sort(int a[]) //array a[] points to arr.   
9. {  
10. Int i, j,temp;     
11.    For(i = 0; i<10; i++)    
12.    {    
13.        For(j = i+1; j<10; j++)    
14.        {    
15.            If(a[j] < a[i])    
16.            {    
17.                Temp = a[i];    
18.                a[i] = a[j];    
19.                a[j] = temp;     
20.            }     
21.        }     
22.    }     
23.    Printf("Printing Sorted Element List ...\n");    
24.    For(i = 0; i<10; i++)    
25.    {    
26.        Printf("%d\n",a[i]);    
27.    }  
28. }  

Output

Printing Sorted Element List ...

7 

9 

10 

12 

23

23 

34 

44 

78 

101 

Returning array from the function

As we know that, a function can not return more than one value. However, if we try to write the return statement as return a, b, c; to return three values (a,b,c), the function will return the last mentioned value which is c in our case. In some problems, we may need to return multiple values from a function. In such cases, an array is returned from the function.

Returning an array is similar to passing the array into the function. The name of the array is returned from the function. To make a function returning an array, the following syntax is used.

1. Int * Function_name() {  
2. //some statements;   
3. Return array_type;  
4. }  

To store the array returned from the function, we can define a pointer which points to that array. We can traverse the array by increasing that pointer since pointer initially points to the base address of the array. Consider the following example that contains a function returning the sorted array.

1. #include<stdio.h>   
2. Int* Bubble_Sort(int[]);  
3. Void main ()    
4. {    
5.    Int arr[10] = { 10, 9, 7, 101, 23, 44, 12, 78, 34, 23};     
6.    Int *p = Bubble_Sort(arr), i;  
7.    Printf("printing sorted elements ...\n");  
8.    For(i=0;i<10;i++)  
9.    {  
10.        Printf("%d\n",*(p+i));  
11.    }  
12. }    
13. Int* Bubble_Sort(int a[]) //array a[] points to arr.   
14. {  
15. Int i, j,temp;     
16.    For(i = 0; i<10; i++)    
17.    {    
18.        For(j = i+1; j<10; j++)    
19.        {    
20.            If(a[j] < a[i])    
21.            {    
22.                Temp = a[i];    
23.                a[i] = a[j];    
24.                a[j] = temp;     
25.            }     
26.        }     
27.    }     
28.    Return a;  
29. }  

Output

Printing Sorted Element List ...

7 

9  

10 

12 

23

23 

34 

44 

78 

101 

Text Books:

[T1] Herbert Schildt, ―C: The Complete Reference‖, OsbourneMcgraw Hill, 4th Edition, 2002.

[T2] Forouzan Behrouz A. ―Computer Science: A Structured Programming Approach Using C, Cengage Learning 2/e

Reference Books:

[R1] Kernighan & Ritchie, ―C Programming Language‖, The (Ansi C version), PHI, 2/e

[R2] K.R Venugopal, ―Mastering C ‖, TMH

[R3] R.S. Salaria "Application Programming in C " Khanna Publishers4/e

[R4] YashwantKanetkar― Test your C Skills ‖ , BPB Publications

[R5] http://www.codeblocks.org/

[R6] http://gcc.gnu.org/

[R7] Programming in ANSI C, E. Balagurusamy; Mc Graw Hill, 6th Edition.