1. POINTERS

2. Outline Introduction Pointer Variable Definitions and Initialization
Pointer Operators
Calling Functions by Reference
Using the const Qualifier with Pointers
Pointer Expressions and Pointer Arithmetic
The Relationship between Pointers and Array
Arrays of Pointers
Pointers to Functions

3. Introduction
Pointer is the address(i.e. a specific memory location) of an object
It can refer to different objects at different times
Pointers are used in C programs for a variety of purposes:
To return more than one value from a function (using pass by reference)
To create and process strings
To manipulate the contents of arrays and structures
To construct data structures whose size can grow or shrink dynamically

4. Pointer Variable Definitions and Initialization
Pointer variables
Contain memory addresses as their values
Normal variables contain a specific value (direct reference)
Pointers contain address of a variable that has a specific value (indirect reference)
Indirection – referencing a pointer value
num 7
num 7
numPtr

5. Pointer Variable Definitions and Initialization
Pointer definitions
* used with pointer variables
int *numPtr;
Defines a pointer to an int (pointer of type int *)
Multiple pointers require using a * before each variable definition
int *numPtr1, *numPtr2;
Can define pointers to any data type
Initialize pointers to 0, NULL, or an address
0 or NULL – points to nothing (NULL preferred)
int *numPtr = NULL; OR int *numPtr = 0;

6. Pointer Operators Symbol & is called address operator
Returns address of operand
int num = 7;
int *numPtr;
numPtr = # /* numPtr gets address of num */
numPtr “points to” num
numPtr
num 7
500000
600000
Address of num is value of numPtr

7. Pointer Operators
Symbol * is called indirection/dereferencing operator
Returns a synonym/alias of what its operand points to
*numPtr returns num (because numPtr points to num)
* can also be used for assignment
Returns alias to an object
*numPtr = 10; /* changes num to 10 */ show pictures!!
Dereferenced pointer (operand of *) must be an lvalue (no constants)
* and & are inverses
They cancel each other out

8. Sample program *numPtr = 15; number = 7
numPtr points to num whereby the value is = 7
Address of numPtr : Contents of numPtr :
Address of num :
Dereferencing pointer, *numPtr = 15
num = 20
*numPtr = 20
*numPtr + num1 = 25
#include <stdio.h>
int main()
{ int num;
int *numPtr;
int num1=5;
num = 7;
printf("number = %d\n", num);
numPtr = &num;
printf("numPtr points to num whereby the value is = %d\n",*numPtr);
printf("Address of numPtr : %d Contents of numPtr : %d\n", &numPtr, numPtr);
printf("Address of num : %d\n\n", &num);
*numPtr = 15;
printf("Dereferencing pointer, *numPtr = %d\n", *numPtr);
num = num + num1;
printf(“num = %d\n”, num);
printf("*numPtr = %d\n", *numPtr);
printf("*numPtr + num1 = %d\n", *numPtr + num1);
return 0; }

9. Calling Functions by Reference
Call by reference with pointer arguments
Pass address of argument using & operator
Allows you to change actual location in memory
Arrays are not passed with & because the array name is already a pointer
* operator
Used as alias/nickname for variable inside of function
void fun1( int *number ) {
*number = 2 * ( *number ); }
*number used as nickname for the variable passed

10. Enter character : f
Do you want to continue?y
Enter character : I
Enter character : k
Do you want to continue?n
Number of vowel : 1
Number of consonant : 2
Remember..last time
#include <stdio.h>
#include <string.h>
char read();
void find_count_vc(char, int*, int*);
void print(int,int);
int main()
{ char ch, choice; int count_v=0,count_c=0; do
{ ch = read();
find_count_vc(ch, &count_v, &count_c);
printf("Do you want to continue?");
scanf("%c", &choice);
getchar();
}while((choice == 'y') ||(choice =='Y'));
print(count_v,count_c);
return 0; }
char read()
{ char ch1;
printf("Enter character : ");
scanf("%c", &ch1);
return(ch1);
void find_count_vc(char ch1, int *vowel, int *consonant) {
switch(ch1)
{ case 'A':
case 'a':
case 'E':
case 'e':
case 'I':
case 'i':
case 'O':
case 'o':
case 'U':
case 'u': *vowel = *vowel +1;break;
default: *consonant = *consonant + 1; }
void print(int vowel, int consonant)
printf("Number of vowel : %d\n", vowel);
printf("Number of consonant : %d\n", consonant);
Functions that “return” more than one value i.e. arguments are passed by ref

11. Remember…last time int main() #include <stdio.h> {
int listA [arraySize] = {0};
int listB [arraySize];
printArray (listA, arraySize);
initializeArray (listB, arraySize);
printArray (listB, arraySize);
fillArray (listA, arraySize);
sumArray (listA, arraySize);
copyArray (listA, listB, arraySize);
return 0; }
#include <stdio.h>
const int arraySize = 10;
void initializeArray (int x [], int sizeX);
void fillArray (int x [], int sizeX);
void printArray (const int x [], int sizeX);
int sumArray (const int x [], int sizeX);
int indexLargestElement (const int x [], int sizeX);
void copyArray (const int x [], int y [], int length);
void initializeArray (int x [ ], int sizeX) {
int counter;
for (counter = 0; counter < sizeX; counter ++)
x [counter] = 0; }

12. Using the const Qualifier with Pointers
Variable cannot be changed
Use const if function does not need to change a variable
Attempting to change a const variable produces an error
const pointers
Point to a constant memory location
Must be initialized when defined
int *const myPtr = &x;
Type int *const – constant pointer to an int
const int *myPtr = &x;
Regular pointer to a const int
const int *const Ptr = &x;
const pointer to a const int
x can be changed, but not *Ptr

13. Pointer Expressions and Pointer Arithmetic
Arithmetic operations can be performed on pointers
Increment/decrement pointer (++ or --)
Add an integer to a pointer( + or += , - or -=)
Pointers may be subtracted from each other
Operations meaningless unless performed on an array

14. Pointer Expressions and Pointer Arithmetic
5 element int array on machine with 4 byte ints
vPtr points to first element v[ 0 ]
at location 3000 (vPtr = 3000)
vPtr += 2; sets vPtr to 3008
vPtr points to v[ 2 ] (incremented by 2), but the machine has 4 byte ints, so it points to address 3008
location
3000
3004
3008
3012
3016
v[0]
v[1]
v[2]
v[3]
v[4]
pointer variable vPtr

15. Pointer Expressions and Pointer Arithmetic
Subtracting pointers
Returns number of elements from one to the other. If
vPtr2 = &v[ 2 ];
vPtr = &v[ 0 ];
vPtr2 - vPtr would produce 2
Pointer comparison ( <, == , > )
See which pointer points to the higher numbered array element
Also, see if a pointer points to 0

16. Pointer Expressions and Pointer Arithmetic
Pointers of the same type can be assigned to each other
If not the same type, a cast operator must be used
Exception: pointer to void (type void *)
Generic pointer, represents any type
No casting needed to convert a pointer to void pointer
void pointers cannot be dereferenced

17. Pointer operation:example
#include <stdio.h>
int main()
{int *vPtr; int *vPtr2;
int v[5] = {10,20,30,40,50}; int temp;
int *p, *q;
vPtr= v;
printf("Address of vPtr : %d Contents of vPtr : %d\n", &vPtr, vPtr);
printf("Address of v[0] : %d\n", &v);
vPtr +=2;
printf("Address of vPtr + 2: %d\n", vPtr);
printf("Address of vPtr + 4: %d\n", vPtr);
vPtr2=&v[2];
vPtr=&v[0];
temp=vPtr2-vPtr;
printf("Contents of temp : %d\n", temp);
p=q;
printf("Contents of p : %d q: %d\n", p,q);
return 0; }
Address of vPtr : Contents of vPtr :
Address of v[0] :
Address of vPtr + 2:
Address of vPtr + 4:
Contents of temp : 2
Contents of p : q:

18. The Relationship Between Pointers and Arrays
Arrays and pointers closely related
Array name like a constant pointer
Pointers can do array subscripting operations
Define an array b[ 5 ] and a pointer bPtr
To set them equal to one another use:
bPtr = b;
The array name (b) is actually the address of first element of the array b[ 5 ]
bPtr = &b[ 0 ]
Explicitly assigns bPtr to address of first element of b

19. The Relationship Between Pointers and Arrays
Element b[ 3 ]
Can be accessed by *( bPtr + 3 )
Where n is the offset. Called pointer/offset notation
Can be accessed by bPtr[ 3 ]
Called pointer/subscript notation
bPtr[ 3 ] same as b[ 3 ]
Can be accessed by performing pointer arithmetic on the array itself
*( b + 3 )

20. Example #include <stdio.h> int main() { int *bPtr ;int i;
Address of bPtr : Contents of bPtr :
Address of b : Contents of b[0]:
bPtr points to b[0] = 10
I am accessing element b[3]!!
Let see how many ways I can do it
b[3] = 40
*(bPtr + 3) = 40
*(b + 3) = 40
bPtr[3] = 40
b[0] = 10
b[1] = 20
b[2] = 30
b[4] = 50
b[5] = 0
b[6] = 0
b[7] = 0
b[8] = 0
b[9] = 0
Example
#include <stdio.h>
int main()
{ int *bPtr ;int i;
int b[10]={10,20,30,40,50};
bPtr = b;
printf("Address of bPtr : %d Contents of bPtr : %d\n", &bPtr, bPtr);
printf("Address of b : %d Contents of b[0]:%d %d %d\n", &b, b[0], *bPtr, *b);
printf("bPtr points to b[0] = %d\n", *bPtr);
printf("\nI am accessing element b[3]!!\nLet see how many ways I can do it\n");
printf("b[3] = %d\n", b[3]);
printf("*(bPtr + 3) = %d\n", *(bPtr + 3));
printf("*(b + 3) = %d\n", *(b + 3));
printf("bPtr[3] = %d\n\n", bPtr[3]);
for(i=0;i<10;i++)
printf("b[%d] = %d\n", i, *(bPtr+i));
return 0; }

21. Arrays of Pointers Arrays can contain pointers
For example: an array of strings
char *suit[ 4 ] = { “Hearts", “Diamonds", "Clubs", "Spades" };
Strings are pointers to the first character
char * – each element of suit is a pointer to a char
The strings are not actually stored in the array suit, only pointers to the strings are stored

22. Arrays of Pointers
suit array has a fixed size, but strings can be of any size
suit[3]
suit[2]
suit[1]
suit[0]
’H’
’e’
’a’
’r’
’t’
’s’
’\0’
’D’
’i’
’m’
’o’
’n’
’d’
’C’
’l’
’u’
’b’
’S’
’p’

23. Example Enter student[0] name : ali #include <stdio.h>
You just entered :
ali
Enter student[1] name : abu
abu
Enter student[2] name : cheah
cheah
Enter student[3] name : dali
dali
Enter student[4] name : gheeta
gheeta
#include <stdio.h>
#define N 5
int main() {
char *studentName[N]; int i;
for(i=0;i<5;i++)
{ printf("Enter student[%d] name : ", i);
scanf("%s", studentName + i);
printf("You just entered :\n%s\n", studentName + i); }
return 0;

24. Pointers to Functions Pointer to function Function pointers can be
Contains address of function
Similar to how array name is address of first element
Function name is starting address of code that defines function
Function pointers can be
Passed to functions
Stored in arrays
Assigned to other function pointers

25. Pointers to Functions Example: bubblesort
Function bubble takes a function pointer
bubble calls this helper function
this determines ascending or descending sorting
The argument in bubblesort for the function pointer:
int ( *compare )( int a, int b )
tells bubblesort to expect a pointer to a function that takes two ints and returns an int
If the parentheses were left out:
int *compare( int a, int b )
Defines a function that receives two integers and returns a pointer to a int

30. Enter 1 to sort in ascending order,
Enter 2 to sort in descending order: 1
Data items in original order
Data items in ascending order
Enter 1 to sort in ascending order,
Enter 2 to sort in descending order: 2
Data items in original order
Data items in descending order