{ int i=500; printf (“address of i = %u”, &i); printf (“Value of i = %d”, i); }

int i=500;

printf (“address of i = %u”, &i);

printf (“Value of i = %d”, i);

Indirection operator, * is also called value at address operator. Its operand is the address of a memory location and it returns the value stored at that address. It works only on pointer variables.

main()

int i=500;

printf (“Address of i = %u”, &i);

printf (“\n Value of i = %d”, i);

printf (“\n Value of i = %d”, *(&i) );

}

will return, Address of i = 65496

Value of i = 500

Value of i = 500

Pointers are declared using the indirection operator, *.

Values can be assigned to pointer variables through the reference operators and the assignment statement.

e.g.:- int i = 500;

int *j;

j = &i;

main()

int i = 500;

int *j;

j = &i;

printf (“\n Address of i = %u”, j);

printf (“\n Address of j = %u”, &j);

printf (“\n Value of j = %u”, j);

printf (“\n Value of i = %d”, i);

printf (“\n Value of i = %d”, *(&i) );

printf (“\n Value of i = %d”, *j);

printf (“\n Value of j = %u”, *(j));

printf (“\n Value of i = %d”, *(*(&j)));

}

Multiple Indirection

It is possible to have a pointer point to another pointer that points to the target value. This situation is called multiple indirection, pointer to pointer. In the case of pointer to a pointer, the first pointer contains the address of the second pointer, which points to the variable that contains the value.

e.g.:- int **k;

main()

int i = 500;

int *j, **k;

j = &i;

printf (“Address of i = %u”, &i);

printf (“\n Address of i = %u”, j);

printf (“\n Address of i = %u”, *k);

printf (“\n Address of j = %u”, &j);

printf (“\n Address of j = %u”, k);

printf (“\n Address of k = %u”, &k);

printf (“\n Value of j = %u”, j);

printf (“\n Value of k = %u”, k);

printf (“\n Value of i = %d”, i);

printf (“\n Value of i = %d”, *(&i) );

printf (“\n Value of i = %d”, *j);

printf (“\n Value of i = %u”, **k);

}

Call by value and Call by reference

Functions communicate with each other by passing arguments. Arguments can generally be passed to functions in one of the two ways.

1. 
   Sending the values of the arguments (Call by value)
   
2. 
   Sending the addresses of the arguments (Call by Reference)
   

# include

void swap(int x, int y);

main()

int i = 10, j = 20;

clrscr();

printf(“Before Swapping”);

printf(“\n i = %d and j = %d”, i, j);

swap(i, j);

printf(“\n i = %d and j = %d”, i, j);

}

void swap(int x, int y)

int t;

y = x;

# include

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

main()

int i = 10, j = 20;

clrscr();

printf(“Before Swapping”);

printf(“\n i = %d and j = %d”, i, j);

swap(&i, &j);

printf(“\n i = %d and j = %d”, i, j);

}

void swap(int *x, int *y)

int t;

*y = *x;

–, ++, – –, * and & are all unary operators having the same precedence of evaluation. When several of these unary operators appear in an expression, the evaluation takes place from right to left.

int i = 500;

int *ptr;

ptr = &i;

When a pointer is passed to a function as argument address of a data item is passed to the function making it possible to access the contents of that address from within the function. This method enables a two-way transfer of data between the calling routine and the called function.

Formal arguments of a function which are pointers are preceded by an asterisk (*) indicating them to be pointers. Function declarations (prototypes) containing pointers must also contain an asterisk (*). Actual pointer arguments in a function call must either be declared pointers or referenced variables. (e.g.:- &var)

e.g.:-

main()

int i, *ptr, j;

ptr = &i;

............

function(ptr, &j);

............

function(int *i, int *j)

..........

return;

}

Pointers and Arrays

The name of an array written without the indices is a pointer-constant, which points to the beginning, (zeroth element) of the array. The array name is a pointer whose value is fixed by the compiler, depending on where the array is stored in memory. The value of pointer constant cannot be changed in the program. But this value can be assigned to a pointer variable.

int num[12], *ptr;

ptr = num;

OR

ptr = &num[0];

Here the array name num, which is a pointer-constant, is assigned to the pointer variable ptr. Both the array name num and ptr point to the first element of array.

main()

int num[10], *ptr, *pa;

ptr = num;

pa = &num[0];

printf(“The array starts at “);

printf(“\n %u ------%u”, ptr, pa);

getch();

}

Q1) Write a program to print the numbers stored in an array using pointers (i.e., without array subscripting)

main()

int arr[10] = {1,2,3,4,5,6,7,8,9,10}, *ptr = arr, i;

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

{

printf(“%d \n”, *ptr++);

getch();

main()

int arr[10] = {1,2,3,4,5,6,7,8,9,10}, *ptr = arr, i;

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

{

*ptr++ += 10;

printf(“%d \n”, *(arr+i));

}

getch();

main()

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

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

{

print(&arr[i]);

getch();

print(int *n)

printf(“%d \n”, *n);

main() print(int *n)

int arr[10] = {1,2,3,4,5,6,7,8,9,10}, i; show(&n);

In order to pass an entire array to a function mention the address of the first element (with subscript 0) of that array as the actual argument (The address of the element with subscript zero is also called the base address. Also you can mention the name of the array instead of the address of first element, because the array name is a pointer-constant that contains the address of the fist element of that array.

The formal argument in the function header of the called function must be a pointer variable to accept the address.


e.g.(1) e.g.:- (2)

main() main()

disp(arr); disp(&arr[0]);

} }

disp(int *arr) disp(int *arr)

int i; int i;

for(i=0; i<3; i++) for(i=0; i<3; i++)

{ {

printf(“%d \n”, *arr); printf(“%d \n”, *arr);

arr++; arr++;

} }

getch(); getch();

main()

char name[] = “Ajith”;

print(char *name) print(char *name)

printf(“%s \n”, name); int i;

for( ; *name != NULL; name++) printf(“%s \n”, name);

{ for(i=0;*(name + i); i++)

printf(“%c \n”, *name); {

getch(); }

}