Lecture 7 C Pointers

1
Lecture 7 C Pointers
Acknowledgment The notes are adapted from those
provided by Deitel Associates, Inc. and Pearson
Education Inc.
2
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

3
Pointer Variable Definitions and Initialization

• Contain memory addresses as their values
• Normal variables contain a specific value (direct
  reference)
• A pointer contains the address of a variable that
  has a specific value (indirect reference)

4
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
• 0 is the only integer value that can be assigned
  directly to a pointer variable.
• Initializing a pointer to 0 is equivalent to
  initializing a pointer to NULL, but NULL is
  preferred
• NULL is a symbolic constant defined in the
  ltstddef.hgt header and several other headers, e.g.
  ltstdio.hgt

5
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

6
Pointer Operators

• (address operator)
• Returns address of operand
• int y 5
• int yPtr
• yPtr y / yPtr gets address of y /
• yPtr points to y

7
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

8

• fig07_04.c (1 of 2 )

If aPtr points to a, then a and aPtr have the
same value.
a and aPtr have the same value
aPtr and aPtr have the same value
9

• fig07_04.c (2 of 2 )

10
Pointer Operator Precedence
11
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

12
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

13

• fig07_06.c

14
Function prototype takes a pointer argument

• fig07_07.c

Function cubeByReference is passed an address,
which can be the value of a pointer variable
In this program, nPtr is number, so this
statement modifies the value of number itself.
15
Analysis of A Typical Call-by-Value
16
Analysis of A Typical Call-by-Reference
17
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

18
Using the const Qualifier with Pointers

• 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
• 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

19
An example of using a non-constant pointer to
non-constant data
Both sPtr and sPtr are modifiable

• fig07_10.c (1 of 2 )

20
Both sPtr and sPtr are modified by the
convertToUppercase function

• fig07_10.c (2 of 2 )

21
An example of using a non-constant pointer to
constant data
Pointer variable sPtr is modifiable, but the data
to which it points, sPtr, is not

• fig07_11.c (1 of 2 )

22
sPtr is modified by function printCharacters

• fig07_11.c (2 of 2 )

23

• fig07_12.c

Pointer variable xPtr is modifiable, but the data
to which it points, xPtr, is not
xPtr has the const qualifier, so attempting to
modify its value causes an error
24

• fig07_13.c

Pointer ptr is not modifiable, but the data to
which it points, ptr, can be changed
25

• fig07_14.c

Neither pointer sPtr nor the data to which it
points, sPtr, is modifiable
26
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

27
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

28

• fig07_15.c (1 of 3 )

29

• fig07_15.c (2 of 3 )

30
Function swap changes the values of the ints that
the two pointers point to

• fig07_15.c (3 of 3 )

31
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

32
sizeof

• 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

33
floats take up 4 bytes in memory, so 20 floats
take up 80 bytes

• fig07_16.c

34

• fig07_17.c (1 of 2 )

35

• fig07_17.c (2 of 2 )

36
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

37
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

38
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

Fig. 7.18 Array v and a pointer variable vPtr
that points to v.
39
The pointer vPtr after pointer arithmetic
40
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 ( lt, , gt )
• See which pointer points to the higher numbered
  array element
• Also, see if a pointer points to 0

41
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

42
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

43
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

44
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 )

45

• fig07_20.c (1 of 3 )

Array subscript notation
Pointer/offset notation
46
Pointer subscript notation
Pointer offset notation

• fig07_20.c (2 of 3 )

47

• fig07_20.c (3 of 3 )

48

• fig07_21.c (1 of 2 )

49
Condition of for loop actually performs an action

• fig07_21.c (2 of 2 )

50
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

51
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 array has a fixed size, but strings can be
  of any size

52
Case study Roman numeral equivalents

• include ltstdio.hgt
• void main( void )
• int decimal_number 101, a 0, b 0
• const char x11 "", "x", "xx", "xxx", "xl",
  "l", "lx", "lxx", "lxxx", "xc", "c"
• const char y10 "", "i", "ii", "iii", "iv",
  "v", "vi", "vii", "viii", "ix"
• while ((decimal_number gt 100) (decimal_number
  lt 0))
• printf("Enter the decimal numbers in the range
  1 to 100\n")
• scanf("d", decimal_number)
• a decimal_number/10
• b decimal_number10
• printf("The equivalent roman is ss\n", xa,
  yb)

53
Case Study A Card Shuffling and Dealing
Simulation

• Card shuffling program
• Use array of pointers to strings
• Use double scripted array (suit, face)
• The numbers 1-52 go into the array
• Representing the order in which the cards are
  dealt

54
Case Study A Card Shuffling and Dealing
Simulation

• Pseudocode
• Top level
• Shuffle and deal 52 cards
• First refinement
• Initialize the suit array
• Initialize the face array
• Initialize the deck array
• Shuffle the deck
• Deal 52 cards

55
Case Study Card Shuffling and Dealing Simulation

• Second refinement
• Convert shuffle the deck to
• For each of the 52 cardsPlace card number in
  randomly selected unoccupied slot of deck
• Convert deal 52 cards to
• For each of the 52 cardsFind card number in deck
  array and print face and suit of card

56
Case Study A Card Shuffling and Dealing
Simulation

• Third refinement
• Convert shuffle the deck to
• Choose slot of deck randomly
• While chosen slot of deck has been previously
  chosen Choose slot of deck randomly
• Place card number in chosen slot of deck
• Convert deal 52 cards to
• For each slot of the deck arrayIf slot contains
  card number Print the face and suit of the
  card

57

• fig07_24.c (1 of 4 )

suit and face arrays are arrays of pointers
58

• fig07_24.c (2 of 4 )

dowhile loop selects a random spot for each card
59

• fig07_24.c (3 of 4 )

60

• fig07_24.c (4 of 4 )

61
(No Transcript)
62
OBJECTIVES

• Pointer variable definitions and initialization
• Pointer operators
• Passing arguments to functions by reference
• Using const qualifier with pointers
• Bubble sort using call-by-reference
• Sizeof operator
• Pointer expressions and pointer arithmetic
• Relationships between pointers and arrays
• Array of pointers
• Case study Card shuffling and dealing simulation
• To use pointers to functions

63
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

64
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 bubble for the function pointer
• int ( compare )( int a, int b )
• tells bubble 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

65
Pointers to Functions

• fig07_26.c (1 of 4 )

bubble function takes a function pointer as an
argument
66
depending on the users choice, the bubble
function uses either the ascending or descending
function to sort the array

• fig07_26.c (2 of 4 )

67

• fig07_26.c (3 of 4 )

Note that what the program considers out of
order is dependent on the function pointer that
was passed to the bubble function
68

• fig07_26.c (4 of 4 )

Passing the bubble function ascending will point
the program here
Passing the bubble function descending will point
the program here
69
(No Transcript)
70
Review

• Pointers data type pointer variable name
  (p, hexadecimal integer)
• Call-by-value (not change) and call-by-reference
  (change)
• Const qualifier make variables not be modified
  (four combinations)
• Sizeof can determine the size in bytes
• Arrays of pointers and case study
• Pointer to function the name of the function is
  the address

71
The End

• Thank you very much!