1

PROGRAMMING
FUNDAMENTALS (EE 170)
By Engr. Salman
Lecturer (Electrical Engineering)
NFC-IEFR, Faisalabad
Pointers

Outline
Introduction
Pointer Variable Definitions and Initialization
Pointer Operators
Calling Functions by Reference
Bubble Sort Using Call by Reference
Pointer Expressions and Pointer Arithmetic
The Relationship between Pointers and Arrays
Arrays of Pointers
Pointers to Functions
Objectives

• In this chapter, you will learn:

– To be able to use pointers.
– To be able to use pointers to pass arguments to
functions using call by reference.
– To understand the close relationships among pointers,
arrays and strings.
– To understand the use of pointers to functions.
– To be able to define and use arrays of strings.
Introduction
 Pointers
 Powerful, but difficult to master
 Simulate call-by-reference

 Close relationship with arrays and strings

Pointer Variable Definitions and
Initialization
 Pointer variables
 Contain memory addresses as their values
 Normal variables contain a specific value (direct
reference) count
7

 Pointers contain address of a variable that has a

specific value (indirect reference)
 Indirection – referencing a pointer value

countPtr count
7
Pointer Variable Definitions and
Initialization
 Pointer definitions
* used with pointer variables
int *myPtr;
 Defines a pointer to an int (pointer of type int *)
 Multiple pointers require using a * before each
variable definition
int *myPtr1, *myPtr2;
 Can define pointers to any data type
 Initialize pointers to 0, NULL, or an address
 0 or NULL – points to nothing (NULL preferred)
Pointer Operators
 & (address operator)
 Returns address of operand
int y = 5;
int *yPtr;
yPtr = &y; /* yPtr gets address of y */
yPtr “points to” y
y yptr y
5 500000 600000 600000 5
yPtr

Address of y
is value of
yptr
Pointer Operators
 * (indirection/dereferencing operator)
 Returns a synonym/alias of what its operand points to
 *yptr returns y (because yptr points to y)

 * can be used for assignment

 Returns alias to an object

*yptr = 7; /* changes y to 7 */
 Dereferenced pointer (operand of *) must be an lvalue
(no constants)
 * and & are inverses
 They cancel each other out
1 /* Fig. 7.4: fig07_04.c
2 Using the & and * operators */
3 #include <stdio.h>
4
The address of a is the value fig07_04.c
5 int main()
of aPtr.
6 {
7 int a; /* a is an integer */
8 int *aPtr; /* aPtr is a pointer to an integer */
9
10 a = 7;
11 aPtr = &a; /* aPtr set to address of a */
12
The * operator returns an alias to
13 printf( "The address of a is %p"
what its operand points to. aPtr
14 "\nThe value of aPtr is %p", &a, aPtr );
points to a, so *aPtr returns a.
15
16 printf( "\n\nThe value of a is %d"
17 "\nThe value of *aPtr is %d", a, *aPtr ); Notice how * and
18 & are inverses
19 printf( "\n\nShowing that * and & are complements of "
20 "each other\n&*aPtr = %p"
21 "\n*&aPtr = %p\n", &*aPtr, *&aPtr );
22
23 return 0; /* indicates successful termination */
24
25 } /* end main */

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
The address of a is 0012FF7C
The value of aPtr is 0012FF7C

The value of a is 7
The value of *aPtr is 7
Program Output
Showing that * and & are complements of each other.
&*aPtr = 0012FF7C
*&aPtr = 0012FF7C

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
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 double( int *number )
{
*number = 2 * ( *number );
}
 *number used as nickname for the variable passed
1 /* Fig. 7.7: fig07_07.c
2 Cube a variable using call-by-reference with a pointer argument */
3
Notice that the function prototype
4 #include <stdio.h>
takes a pointer to an integer. fig07_07.c
5
6 void cubeByReference( int *nPtr ); /* prototype */
7
8 int main()
9 {
10 int number = 5; /* initialize number */
11
12 printf( "The original value of number is %d", number );
13
14 /* pass address of number to cubeByReference */
15 cubeByReference( &number );
Notice how the address of
16
number is given -
17 printf( "\nThe new value of number is %d\n", number );
cubeByReference expects a
18
19 return 0; /* indicates successful termination */
pointer (an address of a variable).
20
21 } /* end main */
22
23 /* calculate cube of *nPtr; modifies variable number in main */ Inside cubeByReference, *nPtr is
24 void cubeByReference( int *nPtr ) used (*nPtr is number).
25 {
26 *nPtr = *nPtr * *nPtr * *nPtr; /* cube *nPtr */
27 } /* end function cubeByReference */
© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
The original value of number is 5
The new value of number is 125

Program Output

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
Before main calls cubeByReference :
int main() number void cubeByReference( int *nPtr )
{ {
5
int number = 5; *nPtr = *nPtr * *nPtr * *nPtr;
}
cubeByReference( &number ); nPtr
} undefined

After cubeByReference receives the call and before *nPtr is cubed:

int main() number void cubeByReference( int *nPtr )
{ {
5
int number = 5; *nPtr = *nPtr * *nPtr * *nPtr;
}
cubeByReference( &number ); nPtr
} call establishes this pointer

After *nPtr is cubed and before program control returns to main :

int main() number void cubeByReference( int *nPtr )
{ { 125
125
int number = 5; *nPtr = *nPtr * *nPtr * *nPtr;
}
cubeByReference( &number ); called function modifies nPtr
} caller’s variable
Bubble Sort Using Call-by-reference
 Implement bubblesort using pointers
 Swap two elements
 swap function must receive address (using &) of array
elements
 Array elements have call-by-value default
 Using pointers and the * operator, swap can switch array
elements
 Psuedocode
Initialize array
print data in original order
Call function bubblesort
print sorted array
Define bubblesort
Bubble Sort Using Call-by-reference
 sizeof
 Returns size of operand in bytes
 For arrays: size of 1 element * number of elements
 if sizeof( int ) equals 4 bytes, then
int myArray[ 10 ];
printf( "%d", sizeof( myArray ) );
 will print 40
 sizeof can be used with
 Variable names
 Type name
 Constant values
1 /* Fig. 7.15: fig07_15.c
2 This program puts values into an array, sorts the values into
3 ascending order, and prints the resulting array. */
4 #include <stdio.h>
5 #define SIZE 10
fig07_15.c (Part 1 of
6 3)
7 void bubbleSort( int *array, const int size ); /* prototype */
8
9 int main()
10 {
11 /* initialize array a */
12 int a[ SIZE ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
13
14 int i; /* counter */ Bubblesort gets passed the
15 address of array elements
16 printf( "Data items in original order\n" );(pointers). The name of an
17 array is a pointer.
18 /* loop through array a */
19 for ( i = 0; i < SIZE; i++ ) {
20 printf( "%4d", a[ i ] );
21 } /* end for */
22
23 bubbleSort( a, SIZE ); /* sort the array */
24
25 printf( "\nData items in ascending order\n" );
26

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
27 /* loop through array a */
28 for ( i = 0; i < SIZE; i++ ) {
29 printf( "%4d", a[ i ] );
30 } /* end for */
31
fig07_15.c (Part 2 of
32 printf( "\n" );
3)
33
34 return 0; /* indicates successful termination */
35
36 } /* end main */
37
38 /* sort an array of integers using bubble sort algorithm */
39 void bubbleSort( int *array, const int size )
40 {
41 void swap( int *element1Ptr, int *element2Ptr ); /* prototype */
42 int pass; /* pass counter */
43 int j; /* comparison counter */
44
45 /* loop to control passes */
46 for ( pass = 0; pass < size - 1; pass++ ) {
47
48 /* loop to control comparisons during each pass */
49 for ( j = 0; j < size - 1; j++ ) {
50

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
51 /* swap adjacent elements if they are out of order */
52 if ( array[ j ] > array[ j + 1 ] ) {
53 swap( &array[ j ], &array[ j + 1 ] );
54 } /* end if */
55
fig07_15.c (Part 3 of
56 } /* end inner for */
3)
57
58 } /* end outer for */
59
60 } /* end function bubbleSort */
61
62 /* swap values at memory locations to which element1Ptr and
63 element2Ptr point */
64 void swap( int *element1Ptr, int *element2Ptr )
65 {
66 int hold = *element1Ptr;
67 *element1Ptr = *element2Ptr;
68 *element2Ptr = hold;
69 } /* end function swap */
Data items in original order
2 6 4 8 10 12 89 68 45 37
Data items in ascending order
2 4 6 8 10 12 37 45 68 89 Program Output

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
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

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
location
3000 3004 3008 3012 3016
has 4 byte ints, so it points to address 3008
v[0] v[1] v[2] v[3] v[4]

pointer variable vPtr

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
Pointer Expressions and Pointer
Arithmetic
 Pointers of the same type can be assigned to each
other
 Ifnot 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
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
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 ]
 Canbe accessed by performing pointer arithmetic on the
array itself
*( b + 3 )
1 /* Fig. 7.20: fig07_20.cpp
2 Using subscripting and pointer notations with arrays */
3
4 #include <stdio.h>
5
fig07_20.c (Part 1 of
6 int main()
2)
7 {
8 int b[] = { 10, 20, 30, 40 }; /* initialize array b */
9 int *bPtr = b; /* set bPtr to point to array b */
10 int i; /* counter */
11 int offset; /* counter */
12
13 /* output array b using array subscript notation */
14 printf( "Array b printed with:\nArray subscript notation\n" );
15
16 /* loop through array b */
17 for ( i = 0; i < 4; i++ ) {
18 printf( "b[ %d ] = %d\n", i, b[ i ] );
19 } /* end for */
20
21 /* output array b using array name and pointer/offset notation */
22 printf( "\nPointer/offset notation where\n"
23 "the pointer is the array name\n" );
24

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
25 /* loop through array b */
26 for ( offset = 0; offset < 4; offset++ ) {
27 printf( "*( b + %d ) = %d\n", offset, *( b + offset ) );
28 } /* end for */
fig07_20.c (Part 2 of
29
2)
30 /* output array b using bPtr and array subscript notation */
31 printf( "\nPointer subscript notation\n" );
32
33 /* loop through array b */
34 for ( i = 0; i < 4; i++ ) {
35 printf( "bPtr[ %d ] = %d\n", i, bPtr[ i ] );
36 } /* end for */
37
38 /* output array b using bPtr and pointer/offset notation */
39 printf( "\nPointer/offset notation\n" );
40
41 /* loop through array b */
42 for ( offset = 0; offset < 4; offset++ ) {
43 printf( "*( bPtr + %d ) = %d\n", offset, *( bPtr + offset ) );
44 } /* end for */
45
46 return 0; /* indicates successful termination */
47
48 } /* end main */

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
Array b printed with:
Array subscript notation
b[ 0 ] = 10
b[ 1 ] = 20
b[ 2 ] = 30
b[ 3 ] = 40
Program Output

Pointer/offset notation where

the pointer is the array name
*( b + 0 ) = 10
*( b + 1 ) = 20
*( b + 2 ) = 30
*( b + 3 ) = 40

Pointer subscript notation

bPtr[ 0 ] = 10
bPtr[ 1 ] = 20
bPtr[ 2 ] = 30
bPtr[ 3 ] = 40

Pointer/offset notation
*( bPtr + 0 ) = 10
*( bPtr + 1 ) = 20
*( bPtr + 2 ) = 30
*( bPtr + 3 ) = 40

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.
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
suit[0] ’H’ ’e’ ’a’ ’r’ ’t’ ’s’ ’\0’

suit[1] ’D’ ’i’ ’a’ ’m’ ’o’ ’n’ ’d’ ’s’ ’\0’

suit[2] ’C’ ’l’ ’u’ ’b’ ’s’ ’\0’

suit[3] ’S’ ’p’ ’a’ ’d’ ’e’ ’s’ ’\0’

 suit array has a fixed size, but strings can be of any

size
Pointers to Functions
 Pointer to function
 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

31

Questions/Answers
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
 Acknowledgement
32

 A large part of the lecture is taken from the slides

of the Text book “Deitel”.