If you declare a variable, its name is a direct reference to its value. If you have a pointer to a variable or any other object in memory, you have an indirect reference to its value. A pointer variable stores the address of another object or a function. To start out, the declaration of a pointer to an object that is not an array has the following syntax:

type * Name [= initializer];

In declarations, the asterisk (*) means "pointer to". The identifier name is declared as an object with the type *, or pointer to type. * is the indirection or dereferencing operator; when applied to a pointer, it accesses the object the pointer points to.

Here is a simple Example

int *iPtr;          // Declare iPtr as a pointer to int.
double *realptr; // pointer to a double
char *astring; // pointer to a character

The type int is the type of object that the pointer iPtr can point to.

To make a pointer refer to a certain object, assign it the address of the object.

For example, if iVar is an int variable, then the following assignment makes iPtr point to the variable iVar:

iPtr = &iVar;       // Let iPtr point to the variable iVar.

In a pointer declaration, the asterisk (*) is part of an individual declarator. We can thus define and initialize the variables iVar and iPtr in one declaration, as follows:

int iVar = 77, *iPtr = &iVar; // Define an int variable and a
                              // pointer to it.

The second of these two declarations initializes the pointer iPtr with the address of the variable iVar, so that iPtr points to iVar. Figure 4.1. illustrates one possible arrangement of the variables iVar and iPtr in memory. The addresses shown are purely fictitious examples. As Figure 4.1. shows, the value stored in the pointer iPtr is the address of the object iVar.

Figure 2: A pointer and another object in memory

It is often useful to output addresses for verification and debugging purposes. The printf() functions provide a format specifier for pointers: %p. The following statement prints the address and contents of the variable iPtr:

printf("Value of iPtr (i.e. the address of iVar): %p\n"
        "Address of iPtr:                          %p\n", iPtr, &iPtr);

The size of a pointer in memory given by the expression sizeof(iPtr)

The unary operator & gives the address of an object, so the statement

p = &c; 

assigns the address of c to the variable p, and p is said to “point to” c. The & operator only applies to objects in memory: variables and array elements. It cannot be applied to expressions, constants, or register variables.

* is the operator that retrieves the value stored at the address held in the pointer. The indirection operator * yields the location in memory whose address is stored in a pointer. If ptr is a pointer, then *ptr designates the object that ptr points to. Using the indirection operator is sometimes called dereferencing a pointer. The type of the pointer determines the type of object that is assumed to be at that location in memory. For example, when you access a given location using an int pointer, you read or write an object of type int.

The indirection operator * is a unary operator; that is, it has only one operand.ptr points to the variable x. Hence the expression *ptr is equivalent to the variable x itself.

double x, y, *ptr;     // Two double variables and a pointer to double.
ptr = &x;              // Let ptr point to x.
*ptr = 7.8;            // Assign the value 7.8 to the variable x.
*ptr *= 2.5;           // Multiply x by 2.5.
y = *ptr + 0.5;      // Assign y the result of the addition x + 0.5.

Do not confuse the asterisk (*) in a pointer declaration with the indirection operator. The syntax of the declaration can be seen as an illustration of how to use the pointer.

double *ptr;

As declared here, ptr has the type double * (read: "pointer to double"). Hence the expression *ptr would have the type double.

Of course, the indirection operator * must be used with only a pointer that contains a valid address. This usage requires careful programming! Without the assignment ptr = &x in the listing above, all of the statements containing *ptr would be senseless dereferencing an undefined pointer value and might well cause the program to crash.

Since pointers are variables, they can be used without dereferencing. Pointer assignment between two pointers makes them point to the same pointee. So the assignment iq = ip; copies the contents of ip into iq, thus making iq point to whatever ip pointed to. It makes iq point to the same pointee as ip. Pointer assignment does not touch the pointees. It just changes one pointer to have the same reference as another pointer. After pointer assignment, the two pointers are said to be "sharing" the pointee.

Example Consider the following programs:

main()
{
  int i = 3, j = 6;
  int *p1, *p2;
  p1 = &i;
  p2 = &j;
  *p1 = *p2;
}
and
main()
{
  int i = 3, j = 6;
  int *p1, *p2;
  p1 = &i;
  p2 = &j;
  p1 = p2;
}

Suppose the values of variables before executing the last assignment are

After the assignment *p1 = *p2; for the first program:

While the assignment p1 = p2 for the second program results

Pointer variables with automatic storage duration start with an undefined value, unless their declaration contains an explicit initializer. You can initialize a pointer with the following kinds of initializers:

A pointer variable is itself an object in memory, which means that a pointer can point to it. To declare a pointer to a pointer , you must use two asterisks, as in the following Example

char c = 'A', *cPtr = &c, **cPtrPtr = &cPtr;

The expression *cPtrPtr now yields the char pointer cPtr, and the value of **cPtrPtr is the char variable c. The diagram in Figure X illustrates these references.

There are times when it’s necessary to have a pointer that doesn’t point to anything. A null pointer is what results when you convert a null pointer constant to a pointer type. A null pointer constant is an integer constant expression with the value 0, or such an expression cast as the type void *.

Null pointers are implicitly converted to other pointer types as necessary for assignment operations, or for comparisons using == or !=. Hence no cast operator is necessary in the previous example.

A pointer to void, or void pointer for short, is a pointer with the type void *. As there are no objects with the type void, the type void * is used as the all-purpose pointer type. In other words, a void pointer can represent the address of any object but not its type. To access an object in memory, you must always convert a void pointer into an appropriate object pointer.

A multidimensional array in C is merely an array whose elements are themselves arrays. The elements of an n-dimensional array are (n-1)-dimensional arrays. For example, each element of a two-dimensional array is a one-dimensional array. The elements of a one-dimensional array, of course, do not have an array type.

A multidimensional array declaration has a pair of brackets for each dimension:

char screen[10][40][80];      // A three-dimensional array.

The array screen consists of the 10 elements screen[0] to screen[9]. Each of these elements is a two-dimensional array, consisting in turn of 40 one-dimensional arrays of 80 characters each. All in all, the array screen contains 32,000 elements with the type char.

Two-dimensional arrays are also called matrices. Because they are so frequently used, they merit a closer look. It is often helpful to think of the elements of a matrix as being arranged in rows and columns. Thus the matrix mat in the following definition has three rows and five columns:

float mat[3][5];

The three elements mat[0], mat[1], and mat[2] are the rows of the matrix mat. Each of these rows is an array of five float elements. Thus the matrix contains a total of 3 x 5 = 15 float elements, as the following diagram illustrates:

The subscript operator [ ] provides an easy way to address the individual elements of an array by index. If myArray is the name of an one dimensional array and i is an integer, then the expression myArray[i] designates the array element with the index i. Array elements are indexed beginning with 0. Thus, if len is the number of elements in an array, the last element of the array has the index len-1.

The following code fragment defines the array myArray and assigns a value to each element.

#define A_SIZE 4
long myarray[A_SIZE];
for (int i = 0;  i < A_SIZE;  ++i)
   myarray[i] = 2 * i;

The diagram in Figure 3 illustrates the result of this assignment loop.

Figure 3: Values assigned to elements by index

To access a char element in the three-dimensional array screen, you must specify three indices. For example, the following statement writes the character Z in a char element of the array:

screen[9][39][79] = 'Z';

If you do not explicitly initialize an array variable, the usual rules apply: if the array has automatic storage duration, then its elements have undefined values. Otherwise, all elements are initialized by default to the value 0.

float a[10];	// declare a float array of size 10
int i;
// read the second element of the array : a[1]
scanf(“%f”,&a[1]);
// Assign an expression  to the third element of the array
a[2] = a[1] + 5;

To read the value for each element of an array, you should use for statement. For example,

int b[10];
int i;
// Read the value for each element of the array
for(i = 0; i < 10; i++)
{
	printf(“\n Enter the value of b[%d]”, i);
	scanf(“%d”,&b[i]);
}

In case you do not now the exact number of elements, declare the maximum number of elements and use a variable to store the actual size of the array

int a[100];	// Declare the array with the number of elements not greater than 100
	int n;			// n is the actual size of the array
	int i;
	printf(“\n Enter the number of elements: “);
	scanf(“%d”,&n);
	for(i = 0; i < n; i++)
	{
		printf("\n a[%d] = ", i);
		scanf("%d",&a[i]);
	}

C allow you to associate initializers with specific elements . To specify a certain element to initialize, place its index in square brackets. In other words, the general form of an element designator for array elements is:

int a[4] = {4, 9, 22, 16};
float b[3] = {40.5, 20.1, 100};
char c[5] = {‘h’, ‘e’, ‘l’, ‘l’, ‘o’};

The first statement is equivalent to four assign statements

a[0] = 4; a[1] = 9; a[2] = 22; a[3] = 16;

printf function are used to print the element of an array. In the following example, we print the element of array a in different ways

#include <stdio.h>
#include <conio.h>
void main()
{
	int a[5];
	int i, k;
	// Read the elements of the array
	for(i = 0; i < 5; i++)
	{
		printf(“\n a[%d] = “, i);
		scanf(“%d”, &a[i]);
	}
	// print the value of element a[3] 
	printf(“\n a[3] = %d”, a[3]);
	// Display all the elements of array a, each element in a line.
	for(i = 0; i < 5; i++)
		printf(“\n%d”, a[i]);
	// Display all the elements of array a in a line
	printf(“\n”);	// change to a new line
	for(i = 0; i < 5; i++)
		printf(“%d  “, a[i]);
	// Display all the elements of array a, k elements in a line
	printf(“\n Enter the value of k = “);
	scanf(“%d”,&k);
	for(i = 0; i < 5; i++)
	{
		printf(“%d  “,a[i]);
		if((i+1)%k == 0)	// change to a new line after printing k     
                              //elements
			printf(“\n”);
	}
	getch();
}

here is the sample session with the above program

 a[0] = 6
 a[1] = 14
 a[2] = 23
 a[3] = 37
 a[4] = 9
 a[3] = 37
 6
 14
 23
 37
 9
 6  14  23  37  9
 Input the value of k = 2
 6  14
 23  37
 9

The purpose of this function is to find the maximum value stored in the array

int a[100];
int i, n;
int max;
printf("\n Enter the size of the array: ");
scanf("%d",&n);
// Read the number of elements of the array
for(i = 0; i < n; i++)
{
	printf("\n a[%d] = ",i);
	scanf("%d",&a[i]);
}
// Find the maximum element
max = a[0];	// max is initialized by a[0]
// compare max to other elements
for(i = 1; i < n; i++)
	if(max < a[i])		//meet an element greater than max
		max = a[i];	// replace max by the new value from the elements.
printf("\n The maximum element of the array is: %d", max);

The simplest type of searching process is the sequential search. In the sequential search, each element of the array is compared to the key, in the order it appears in the array, until the first element matching the key is found. If you are looking for an element that is near the front of the array, the sequential search will find it quickly. The more data that must be searched, the longer it will take to find the data that matches the key using this process.

here is the sample session with the above program

#include <stdio.h>
#include <conio.h>
void main()
{
	int m[100], idx[100];
	int n;	// n is the actual size of the array
	int i, k, test;
	clrscr();	// clear screen
	// Read array m
	// Read the actual size of m
	printf(“ Enter the number of elements
	scanf(“%d”,&n);
	// Read array’s elements
for(i  = 0;i<n;i++)
	{
		int temp;
	printf(“\n Enter the value of m[%d] = “,i);
		scanf(“%d”,&temp);
		m[i] = temp;
	}
	// Read the searching key k
	printf(“\n Enter the value you want to search : “);
	scanf(“%d”,&k);
	// Begin searching
	test = 0;
	// Scan all the elements
	for(i = 0;i<n;i++)
		if(m[i] = = k)//Compare the current element with the           
                          //searching key k
		{
			// save the index of the current element
			idx[test] = i;
test ++; 
		}
	// Conclusion
	if(test > 0)
	{
		printf(“\n there are %d elements which has the value of %d”,test,k);
		printf(“\n Indexes of those elements: “);
		for(i = 0;i < test;i++)
			printf(“%3d”,idx[i]);
	}
	else
		printf(“\n No element has the value %d”,k);
	getch();	// Wait until the user press any key
}

Selection sort is a sorting algorithm, specifically an in-place comparison sort. Selection sort is noted for its simplicity, and also has performance advantages over more complicated algorithms in certain situations. It works as follows:

Effectively, we divide the list into two parts: the sublist of items already sorted, which we build up from left to right and is found at the beginning, and the sublist of items remaining to be sorted, occupying the remainder of the array.

Here is an example of this sort algorithm sorting five elements:

31 25 12 22 11
11 25 12 22 31
11 12 25 22 31
11 12 22 25 31

#include <stdio.h>
#include <conio.h>
void main()
{
	int m[100];//100 is the maximum size for array m
	int n;	// n is the number of elements	int i, j, k;
	clrscr();	// clear screen 
	// Read the elements of array m
	// Read the actual size of the array

	printf(“ Enter the number of elements: “);
	scanf(“%d”,&n);
	// Read array elements 
for(i  = 0;i<n;i++)
	{
		int temp;
	printf(“\n Enter the value of m[%d] = “,i);
		scanf(“%d”,&temp);
		m[i] = temp;
	}
	// Print the array 
	printf(“\n The array before sorting:    “);
	for(i=0;i<n;i++)
		printf(“%3d”,m[i]);
	// Begin to sort
	for(i = 0; i<n-1;i++)
	{
		// Put the minimum value in the list of n-i elements
           //to the ith position 
	for(j = i+1;j<n;j++)
		{
			// compare m[i] with other element of the sublist
// and swap m[i] and m[j] if m[j] < m[i].
			if(m[j]<m[i])
			{
				int temp;
				temp = m[j]; m[j] = m[i]; m[i] = temp;
			}
		}
		// Print the array after the i+1 th step of sorting process
printf(“\n The array after step %d”,i+1);
		for(k = 0;k < n ;k++)
printf(“%3d”,m[k]);
	}
	getch();	// Wait until the user press any key.
}

here is the sample session with the above program

Enter the number of elements:  : 5
Enter the value of m[0]: 34
Enter the value of m[1]: 20
Enter the value of m[2]: 17
Enter the value of m[3]: 65
Enter the value of m[4]: 21
The array before sorting:    34 20 17 65 21
The array after step 1: 17 34 20 65 21
The array after step 2: 17 20 34 65 21
The array after step 3: 17 20 21 65 34
The array after step 4: 17 20 21 34 65