ASTU

CSE 1062 Fundamentals of Programming

Lecture #9

Spring 2017

Computer Science & Engineering Program

The School of EE & Computing
Adama Science & Technology University
Outline ASTU

• Arrays
– One-dimensional arrays
– Array initialization
– Declaring and processing two-dimensional arrays
– Arrays as arguments
• Pointers
– Addresses and pointers
– Array names as pointers
– Pointer arithmetic
– Passing addresses
Case Studies: Statistical Analysis
[Data Processing] Students’ Grading
Reading assignment
– Chapter 7 of the textbook
– Chapter 10 of the textbook
– Read about <cstring> library
– Read about Standard Template Library and Vectors

2
One-Dimensional Arrays ASTU

• One-dimensional array: A list of related

values with the same data type, stored
using a single group name (called the
array name)
• Syntax:
dataType arrayName[number-of-items]
• By convention, the number of items is
first declared as a constant, and the
constant is used in the array declaration

3
One-Dimensional Arrays (continued) ASTU

Figure 7.1 The volts and code arrays in memory

4
One-Dimensional Arrays (continued) ASTU

• Element: An item in the array

– Array storage of elements is contiguous
• Index (or subscript) of an element: The
position of the element within the array
– Indexes are zero-relative
• To reference an element, use the array
name and the index of the element

5
One-Dimensional Arrays (continued) ASTU

• Index represents the offset from the start

of the array
• Element is also called indexed variable
or subscripted variable
• Subscripted variable can be used
anywhere that a variable can be used
• Expressions can be used within the
brackets if the value of the expression
• Yields an integer value
• Is within the valid range of subscripts

6
One-Dimensional Arrays (continued) ASTU

• All of the elements of an array can be

processed by using a loop
• The loop counter is used as the array
index to specify the element
• Example:
sum = 0;
for (i=0; i<5; i++)
sum = sum + temp[i];

7
Input and Output of Array Values ASTU

• Array elements can be assigned values

interactively using a cin stream object
• Out of range array indexes are not
checked at compile-time
– May produce run-time errors
– May overwrite a value in the referenced
memory location and cause other errors
• Array elements can be displayed using
the cout stream object

8
Input and Output of Array Values ASTU

9
Array Initialization ASTU

• Array elements can be initialized in the

array declaration statement
• Example:
int temp[5] = {98, 87, 92, 79, 85};
• Initialization:
– Can span multiple lines, because white space is
ignored in C++
– Starts with array element 0 if an insufficient
number of values is specified
• If initializing in the declaration, the size may
be omitted

10
Array Initialization ASTU

• char array will contain an extra null

character at the end of the string
• Example:
char codes[] = “sample”;

11
Array Initialization ASTU

12
Two-Dimensional Arrays ASTU

• Two-dimensional array: Has both rows

and columns
• Also called a table
• Both dimensions must be specified in
the array declaration
• Row is specified first, then column
• Both dimensions must be specified when
referencing an array element

13
Two-Dimensional Arrays ASTU

• Example:
int val[1][3];

14
Two-Dimensional Arrays ASTU

• Two-dimensional arrays can be initialized

in the declaration by listing values within
braces, separated by commas
• Braces can be used to distinguish rows,
but are not required
• Nested for loops are used to process
two-dimensional arrays
– Outer loop controls the rows
– Inner loop controls the columns

15
Two-Dimensional Arrays: Displaying ASTU

16
Two-Dimensional Arrays: Displaying ASTU

17
Two-Dimensional Arrays: Multiplying Elements ASTU

18
Larger Dimensional Arrays ASTU

• Arrays with more than two dimensions

can be created, but are not commonly
used
• Think of a three-dimensional array as a
book of data tables

19
Arrays as Arguments ASTU

• An individual array element can be passed

as an argument just like any individual
variable
• The called function receives a copy of the
array element’s value
• Passing an entire array to a function causes
the function to receive a reference to the
array, not a copy of its element values
• The function must be declared with an
array as the argument
• Single element of array is obtained by
adding an offset to the array’s starting
location
20
Arrays as Arguments ASTU

21
Arrays as Arguments: Finding Maximum ASTU

22
Arrays as Arguments: Using 2D arrays ASTU

23
Case Study 1: Statistical Analysis ASTU

• A program is to be developed that

accepts a list of a maximum of 100
numbers as input, determines both the
average and standard deviation of the
numbers, and then displays the result.

24
Step 1: Analyze the Problem ASTU

• The statement of the problem indicates that

– Two output values are required:
• an average and a standard deviation.
– The input item is a list of integer numbers.
– The problem statement doesn’t specify the list size
• make the application’s functions as general as possible,
both functions will be designed to handle any size list
passed to them.
• This design also requires passing the exact number of
array elements to each function at the time of the function
call.
• This capability means each function must be capable of
receiving at least two input items as parameters
– an array of arbitrary size and an integer number corresponding
to the number of elements in the passed array.

25
Step 2: Develop a Solution ASTU

• The I/O specifications determined from the

problem analysis imply that each function’s
parameter list must be capable of receiving
at least two items
– one parameter to accommodate the integer
array
– the second parameter to accept an integer.
• The first function returns the average of the
numbers in the passed array
• The second function returns the standard
deviation. These items are determined as
follows:
26
Step 2: Develop a Solution ASTU

27
Step 3, 4: Code, Test and Correct the Solution ASTU

28
Step 3, 4: Code, Test and Correct the Solution ASTU

29
Case Study 2: Students’ Grading Program ASTU

• A program that uses a two-dimensional

array named grade to store and then
display the grade records for a small
class.
• The class has four students, and the
records include three quizzes.
– Reads quiz scores for each student into the
two-dimensional array grade
– Compute the average score for each student
– Compute the average score for each quiz.
– Displays the quiz scores and the averages.

30
Case Study 2: Students’ Grading Program ASTU

31
Case Study 2: Students’ Grading Program ASTU

32
Case Study 2: Students’ Grading Program ASTU

33
Testing the Program ASTU

34
Addresses and Pointers ASTU

• The address operator, &, accesses a

variable’s address in memory
• The address operator placed in front of a
variable’s name refers to the address of
the variable
&num means the address of num

35
Addresses and Pointers ASTU

36
Storing Addresses ASTU

• Addresses can be stored in a suitably

declared variable

37
Storing Addresses ASTU

• Example statements store addresses of

the variable m, list, and ch in the
variables d, tabPoint, and chrPoint
d = &m;
tabPoint = &list;
chrPoint = &ch;
• d, tabPoint, and chrPoint are called
pointer variables or pointers

38
Storing Addresses ASTU

39
Using Addresses ASTU

• To use a stored address, C++ provides

the indirection operator, *
• The * symbol, when followed by a
pointer, means “the variable whose
address is stored in”
*numAddr means the variable whose
address is stored in numAddr

40
Using Addresses ASTU

41
Using Addresses ASTU

• When using a pointer variable, the value

that is finally obtained is always found
by first going to the pointer for an
address
• The address contained in the pointer is
then used to get the variable’s contents
• Since this is an indirect way of getting to
the final value, the term indirect
addressing is used to describe it

42
Declaring Pointers ASTU

• Like all variables, pointers must be declared

before they can be used to store an
address
• When declaring a pointer variable, C++
requires specifying the type of the variable
that is pointed to
– Example: int *numAddr;
• To understand pointer declarations, reading
them “backward” is helpful
– Start with the indirection operator, *, and
translate it as “the variable whose address is
stored in” or “the variable pointed to by”
43
Declaring Pointers ASTU

44
Pointers: Example ASTU

45
References and Pointers ASTU

• A reference is a named constant for an address

– The address named as a constant cannot be
changed
• A pointer variable’s value address can be
changed
• For most applications, using references rather
than pointers as arguments to functions is
preferred
– Simpler notation for locating a reference parameter
– Eliminates address (&) and indirection operator (*)
required for pointers
• References are automatically dereferenced, also
called implicitly dereferenced
46
Array Names as Pointers ASTU

• There is a direct and simple relationship

between array names and pointers

• Using subscripts, the fourth element in grade is referred

to as grade[3], address calculated as:
&grade[3] = &grade[0] + (3 * sizeof(int))

47
Array Names as Pointers ASTU

48
Array Names as Pointers ASTU

49
Array Names as Pointers: Example ASTU

50
Pointer Arithmetic ASTU

• Pointer variables, like all variables,

contain values
• The value stored in a pointer is a
memory address
• By adding or subtracting numbers to
pointers you can obtain different
addresses
• Pointer values can be compared using
relational operators (==, <, >, etc.)

51
Pointer Arithmetic ASTU

52
Pointer Arithmetic ASTU

53
Pointer Arithmetic: Example ASTU

54
Pointer Initialization ASTU

• Increment and decrement operators can be

applied as both prefix and postfix operators

• Of the four possible forms, *ptNum++ is

most common
– Allows accessing each array element as the
address is “marched along” from starting
address to address of last array element

55
Pointer Initialization ASTU

• Pointers can be initialized with they are

declared
int *ptNum = &miles;
• Pointers to arrays can also be initialized
when they are declared
double *zing = &volts[0];

56
Passing Addresses ASTU

• Reference pointers can be used to pass

addresses through reference parameters
– Implied use of an address
• Pointers can be used explicitly to pass
addresses with references
– Explicitly passing references with the address
operator is called pass by reference
– Called function can reference, or access,
variables in the calling function by using the
passed addresses

57
Passing Addresses: Example ASTU

58
Passing Addresses ASTU

59
Passing Addresses ASTU

60
Passing Arrays ASTU

• When an array is passed to a function,

its address is the only item actually
passed
– “Address” means the address of the first
location used to store the array
– First location is always element zero of the
array

61
Passing Arrays ASTU

62
Passing Arrays: Example ASTU

63