View
218
Download
1
Category
Preview:
Citation preview
1
Pointers and Strings
Chapter 5
2
What You Will Learn . . .
How to use pointers
Passing arguments to functions with pointers See relationship of
pointers to strings and arrays
Pointers can point to functions
Declaring & using arrays of strings
3
Introduction
Pointer variables contain memory addresses as their values
Contrast normal variables which contain a specific value
x holds a value xptr holds memory address of some int location
int *xptr, x;
x 5
xptr
4
Pointer Variable Declarations and Initializations Must declare the type of variable to which
pointer variable will point
Must use the leading * to specify this is a pointer variable
Good idea to include ptr in the name of the pointer variable
float amt, *fptr;
5
Pointer Initialization
When declared, variables should NOT be assumed to have any certain value
As with all variables, pointer variables should be explicitly initialized– Initialized with address of a specific
variable– Initialized to 0 or NULL (points to nothing)
6
Pointer Operators
Address operator &– unary operator– returns address of operand
int *xptr, x;
x = 5;
xptr = &x;
x 5
xptr
7
Pointer Operators
Address operator &– unary operator– returns address of operand
int *xptr, x;
x = 5;
xptr = &x;x 5
xptr 1234
1234
6500
Address
Values actually stored
8
Pointer Operators
The indirection or dereferencing operator– Use the * symbol
*xptr will yield the value stored at the location to which xptr points
int x, *xptr;x = 50;xptr = &x;cout << *xptr;// what gets printed?
50
9
Pointer Operators
The precedence of – & the address operator– * the dereferencing operator
Higher precedence than multiplication and division
Lower precedence than parentheses
10
Calling Functions by Reference
Three ways to pass arguments to a function– call by value– call by reference with reference
parameters– call by reference with pointer parameters
void doit (int amt);void whatever ( float &value);void fribble (char *ch);
11
Calling Functions by Reference
Call by value– value gets passed one way (to the function) only– can use constant, expression, or variable in call
Reference parameter– value passed both ways– must use variable in call– parameter automatically dereferenced locally
12
Calling Functions by Reference
Must use address in call – use address operator
fribble (&c1); Must explicitly dereference locally within
function– use * operator
void fribble (char *ch){ *ch = …. ; }
13
Using the const Qualifier with Pointers Recal that const informs the compiler
that the value of a "variable" should not be modified
This can also be used on function parameters so that actual parameters are NOT affected by changes in formal parameters
void try_a_change (const char *s_ptr)
14
const Used on Parameters
When used, do not try to alter contents of where pointer points to
void double_int (const int *num_ptr){ *num_ptr = 2 * *num_ptr;}
compiler error
15
const Used on Parameters
Consider the advantage of passing large data objects (structures, arrays) using points to constant data– saves memory
• function does not need to create duplicate data object
– saves time• program need not copy large number of bytes
to the local object
16
Bubble Sort Using Call-by-reference Refer to “Cyber Classroom” CD for
author’s description of the program Run the program
17
Bubble Sort Using Call-by-reference -- Note ... array declared as int *array
not int array [ ] Parameter size declared as const to
enforce sorting function not altering size– when passing an array to function, send size
also -- don’t have it built in Prototype for swap included inside
bubbleSort -- it is the only function that calls swap
18
Pointer Expressions & Pointer Arithmetic Pointer values are valid operands in
expressions– arithmetic– assignment– comparison
Not all such operators are valid with pointer variables
19
Pointer Expressions & Pointer Arithmetic Valid operations on pointers
++ - - + += - - =
int v[5], *vPtr;vPtr = v; // same as vPtr = &v[0];
20
Pointer Expressions & Pointer Arithmetic Consider:
vPtr += 2; // same as vPtr = vPtr + 2;
/* But, beware of vPtr -= 4; Why?
21
Pointer Expressions & Pointer Arithmetic -- warnings !! Beware use of pointer arithmetic on pointers
which do not reference an array Consider results of subtracting or comparing two
pointers which do not reference the same array C++ has no range checking -- if you run off the
end of an array, you can be in trouble Pointers can be assigned to other pointers only
if they are pointers to the same type– although typecasting can be used (carefully)
22
Pointers to void ( void * )
This is a generic pointer– can represent any pointer type
All pointer types can be assigned a pointer to void without casting
A pointer to void cannot be be assigned a pointer of another type (without casting)
Void pointer cannot be dereferenced(why not??)
23
Relationship Between Pointers and Arrays
// Givenint list [5], *intPtr;intPtr = list; // name of array is a pointer constant, an address
Then we can use eitherlist[2] or *(intPtr + 2)
to reference the second element of the array The former is clearer but takes longer to
compile
24
Relationship Between Pointers and Arrays Note how pointer is used to traverse
array:
int b[] = { 10, 20, 30, 40 };int *bPtr = b; // set bPtr to point to array b
for ( offset = 0; offset < 4; offset++ ) cout << "*(bPtr + " << offset << ") = " << *( bPtr + offset ) << '\n';
for (bPtr = b; bPtr < b + 4; bPtr++) cout << *bPtr << '\n'; How are these
two different?How are these two different?
25
Relationship Between Pointers and Arrays What is wrong with this use of the name
of the array?
for ( bPtr = b ; b < bPtr + 4; b++ ) cout << *b << '\n';
The name of the array is a pointer constant
The name of the array is a pointer constant
26
Arrays of Pointers
Common use is for an array of strings (character arrays)char *suit [4] = {"Hearts","Diamonds", "Clubs", "Spades"};
27
Arrays of Pointers
Character values stored in memory, one byte longer than length of string
Array suit actually holds pointers to these locations– point to first character of each string
Note that memory not wasted for unneeded characters of shorter strings
char *suit [4] = {"Hearts","Diamonds", "Clubs", "Spades"};char *suit [4] = {"Hearts","Diamonds", "Clubs", "Spades"};
28
Function Pointers
Pointer to a function contains the address of the function in memory
A function name is a pointer constant to the starting address in memory of the code of the function
Pointers to functions can be …– passed as parameters (both directions)– stored in arrays– assigned to other function pointers
29
Function Pointers Consider the following code:
Function sort receives a pointer to a function– function ascending
– function descending
void bubble( int [], const int, int (*)( int, int ) );int ascending( int, int );int descending( int, int ); . . . void bubble( int work[], const int size, int (*compare)( int, int ) )
depending onpointer passed in call
30
Function Pointers
Sending a function name as the actual parameter sends the address of that function to another function
if ( order == 1 ) { bubble( a, arraySize, ascending ); cout << "\nData items in ascending order\n"; } else { bubble( a, arraySize, descending ); cout << "\nData items in descending order\n"; }
31
Function Pointers
Consider an array of functions
void (*f [3] ) ( int ) = { f1, f2, f3 }; Assumptions
– f1, f2, and f3 have been previously declared– each has a single int parameter– they are called with an array number
f [ choice ] (x_int);
32
Characters and Strings
Character constant– an integer value represented as a
character in single quotes 'x' or '\t' String
– series of characters treated as a single unit String constants (string literals)
– enclosed in double quotes "Hi Mom" "2/14/1999"
33
Strings
An array of characters ending in the null character '\0'
Accessed via pointer to first character in the string
Value of a string– the constant address of its first character
Assigned in declaration as array or char pointer char name[ ] = "Snuffy Snail"; char *addr = "123 Frogpond";
34
Strings
Make sure to allocate enough characters in the array to have room for the '\0'
If you create a "string", make sure the '\0' gets tagged on the end
Passing a character as a parameter when a string is expected can cause run time problems
Vice-versa is a syntax error
35
String Manipulation Functions
Recall that strings must be handled in a special manner char name[30]; name = "Osgood Smart";
Use functions provided– See page 325
– make sure to
#include <string.h>#include <string.h>
Don't do it!! Why?
Recommended