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 (e.g: array) 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
indirect reference

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; // variable num=7
int *numPtr; // pointer variable named numPtr // initialized as integer data type
numPtr = # /* numPtr gets address of num */
numPtr “points to” num based on address of variable num
numPtr
num 7
500000
600000
Address of num is value of numPtr
value
address

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; /* assign/changes num to 10 */
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. 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; }

11. 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

12. Using const Qualifier with pointer
The const Qualifier enables the programmer to inform the compiler that the value of a particular variable should not be modified.
const qualifier
Variable cannot be changed
Use const if function does not need to change a variable
Attempting to change a const variable produces an error

13. Using the const Qualifier with Pointers
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
Non-constant data,
Constant pointer
Constant data,
Non -constant pointer
Constant data,
Constant pointer

14. Pointer Expressions and Pointer Arithmetic
A limited set of arithmetic operations may 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

15. Pointer Expressions and Pointer Arithmetic
Assume, array int v[5] has been defined and its first element is at location 3000 in memory.
Assume vPtr has been initialized to point to v[0], i.e the value of the vPtr is 3000.
The initialization can be either of the following statements.
vPtr=v;
vPtr=&v[0];

16. Pointer Expressions and Pointer Arithmetic
5 element int array on machine with 4 byte integers
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

17. Pointer Expressions and Pointer Arithmetic
Subtracting pointers
Returns number of elements from one to the other. If
vPtr2 = &v[ 2 ]; // address 3008
vPtr = &v[ 0 ]; // address 3000
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

18. 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

19. 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:

20. 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

21. 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 )

22. 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)); // print all elements
return 0; }

23. 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

24. 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’

25. 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;

26. 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

27. 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

28. During Lecture session
Assignment
Explain bubble sort operation (pointers to functions concept) as done in previous lab exercise.
Submit on:
Next Monday
During Lecture session

33. 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