Understanding Arrays and Pointers

Lecture 2 Understanding Arrays and Pointers COSC1567 C++ Programming

Objectives • Address operator • Arrays • Store values in an array • Access and use array values • Array’s size • Parallel arrays • C-style strings • Special string-handling problems • Pointers • Use a pointer to access an array • Multidimensional arrays

Using the Address Operator • A variable’s memory address is a fixed location; a variable’s address is a constant • Although you cannot choose a variable’s actual memory address, you can examine it • To do so, you use the address operator (&) • The memory address is of not use to you at this point; you use the address operator merely as a curiosity • The hexadecimal numbering system uses the values 0 through 9, and the letters a through f to represent the decimal values 0 through 15

Using the Address Operator Ex2-1.cpp //console I/O

Understanding Arrays • A list of individual items that all have the same type is called an array • An array holds two or more variables with the same name and type in adjacent memory positions • The variables with the same name are distinguished from one another by their subscripts; the subscript is a number that indicates the position of the particular array element being used • Anytime you need many related variables, consider using an array

Understanding Arrays • In C++, you declare an array by using the form type arrayName [size];where type is any simple type, arrayName is any legal identifier, and size (in the square bracket) represents the number of elements the array contains • An element is a single object in an array • An array name actually represents a memory address • When you declare an array, you tell the compiler to use the array name to indicate the beginning address of a series of elements

Understanding Arrays

Storing Values in an Array • You most often create an array when you want to store a number of related variable elements • When you declare an array like int array [4]; you set aside enough memory to hold four integers, but you say nothing about the values stored in those four memory locations • The values are unknown—they are whatever was stored in those memory locations before the computer reserved the locations for use by your program • Programmers often say that these memory locations are filled with garbage, or useless values

Storing Values in an Array • Just as you can initialize a single variable when you declare it, you can provide values for an array when you declare it • The statement int rent[4] = {250, 375, 460, 600}; provides four values for the array • If you declare an array without a size, but provide initialization values, C++ creates an array with the exact size you need • If you do not provide enough values to fill an array, C++ fills any unassigned array elements with zeros

Ex2-2.cpp & Ex2-3.cpp Program that Uses Single and Array Variables

Accessing and Using Array Values The for loop prints arrayInt[0] through arrayInt[4] because x increases from 0 and remains less than 5 The user will be prompted 10 times and allowed to enter a floating point value after each prompt. The 10 values will be stored in price[0] through price[9], respectively

Using a Constant to Refer to an Array’s Size • Often, using a for loop is a convenient way to access all array elements because arrays always have a specific, known size, and for loops execute a specific, known number of times • When you want to access all array elements in sequential order, you can use a subscript that you vary from 0 to 1 less than the number of elements of the array

Using a Constant to Control Loops Ex2-5.cpp A program that declares an array with 12 elements

Accessing Elements in an Array • When you want to access a single array element, you use a subscript that indicates the position of the value you want to access • When you want to access all of the elements in an array, a for loop usually is convenient • A sentinel or dummy is any value that stops a loop’s execution

A Program That Averages Up to 30 Test Scores Ex2-6.cpp The program declares an array for 30 integer test scores, and single variables that serve as subscripts, a total, and the average

Using Parallel Arrays • When you want to access an array element, you use the appropriate subscript • If each array element’s position has a logical connection to the array value’s purpose, accessing an array value is a straightforward process • Sometimes the numbers you need to access appropriate array values are not small whole numbers

A Program That Determines Insurance Premiums Ex2-7.cpp

Using Parallel Arrays • A better solution is to create two arrays of just four elements each—one to hold the four part numbers, and one to hold the four prices that correspond to those part numbers • Such corresponding arrays are called parallel arrays

Program That Determines Part Prices Ex2-8.cpp

Initializing Arrays • As simple variables can be initialized atdeclaration:int price = 0; // 0 is initial value • Arrays can as well:int children[3] = {2, 12, 1}; • Equivalent to following:int children[3];children[0] = 2;children[1] = 12;children[2] = 1;

Auto-Initializing Arrays • If fewer values than size supplied: • Fills from beginning • Fills "rest" with zero of array base type • If array-size is left out • Declares array with size required based onnumber of initialization values • Example:int b[] = {5, 12, 11}; • Allocates array b to size 3

Arrays in Functions • As arguments to functions • Indexed variables • An individual "element" of an array can be function parameter • Entire arrays • All array elements can be passed as "one entity"

Indexed Variables as Arguments • Indexed variable handled same as simplevariable of array base type • Given this function declaration:void myFunction(double par1); • And these declarations:int i; double n, a[10]; • Can make these function calls:myFunction(i); // i is converted to doublemyFunction(a[3]); // a[3] is doublemyFunction(n); // n is double

Subtlety of Indexing • Consider:myFunction(a[i]); • Value of i is determined first • It determines which indexed variable is sent • myFunction(a[i*5]); • Perfectly legal, from compiler’s view • Programmer responsible for staying"in-bounds" of array

Entire Arrays as Arguments • Formal parameter can be entire array • Argument then passed in function callis array name • Called "array parameter" • Send size of array as well • Typically done as second parameter • Simple int type formal parameter

Entire Array as Argument Example: Display 5.3 Function with an Array Parameter Ex2-9.cpp

Entire Array as Argument Example • Given previous example: • In some main() function definition,consider this calls: int score[5], numberOfScores = 5; fillup(score, numberOfScores); • 1st argument is entire array • 2nd argument is integer value • Note no brackets in array argument!

Array as Argument: How? • What’s really passed? • Think of array as 3 "pieces" • Address of first indexed variable (arrName[0]) • Array base type • Size of array • Only 1st piece is passed! • Just the beginning address of array • Very similar to "pass-by-reference"

Array Parameters • May seem strange • No brackets in array argument • Must send size separately • One nice property: • Can use SAME function to fill any size array! • Exemplifies "re-use" properties of functions • Example:int score[5], time[10];fillUp(score, 5);fillUp(time, 10);

The const Parameter Modifier • Recall: array parameter actually passesaddress of 1st element • Similar to pass-by-reference • Function can then modify array! • Often desirable, sometimes not! • Protect array contents from modification • Use "const" modifier before array parameter • Called "constant array parameter" • Tells compiler to "not allow" modifications

Programming with Arrays • Plenty of uses • Partially-filled arrays • Must be declared some "max size" • Sorting • Searching

Partially-filled Arrays • Difficult to know exact array size needed • Must declare to be largest possible size • Must then keep "track" of valid data in array • Additional "tracking" variable needed • int numberUsed; • Tracks current number of elements in array

Creating Arrays of Class Objects • Just as you can create arrays of simple types such as int and double, you can create arrays of class objects • To access any individual class object field, you use the object’s individual name, including its subscript, followed by a dot and the field name

Creating an Array of Class Objects This program creates an array of four Automobile objects. Ex2-10.cpp

Using C-Style Strings • In C++, a character variable can hold a single character value, such as ‘A’ or ‘$’ • Single character values are always expressed within single quotation marks • In C++, if you want to express multiple character values, such as a first name or a book title, you use double quotation marks • A C++ value expressed within double quotation marks is commonly called a string

Using C-Style Strings • You already have used strings with cout statements, as in cout<<“Hello”; • Just as a value such as 14 is a numeric constant, a value such as “Hello” is referred to as a string constant • In C++ an array of characters and a string are declared in the same way • You might create an array of characters if you need to store six one-letter department codes, or five one-letter grades that can be assigned on a test

Using Strings • The null character is represented by the combination ‘\0’ (backslash and zero), or by using the constant NULL that is available if you use the statement #include <iostream> at the top of any file you compile

Special String Handling Problems • String present some special handling problems • When you use the cin statement with a string, cin stops adding characters to the string when it encounters white space • Often, this means that cin stops when the user presses the Enter key • But cin also stops when the user presses the spacebar or the Tab key

A Program That Reads a Name

Special String Handling Problems • Another string handling problem occurs when you attempt to assign one string to another • To assign the name of the clubPresident to the same name as the clubVicePresident, you must assign each character value in the clubVicePresident name to the corresponding character location in the clubPresident name • A related string-handling problem occurs when you try to compare two strings

Special String Handling Problems • If you want to determine whether clubPresident and clubVicePresident have the same name, it might seem natural to write a statement such as: if(clubPresident == clubVicePresident) cout<<“They are the same”<<endl; • You could write instructions to compare two strings by each character of one string to the corresponding character in the other string, such as in the following: if(clubPresident[0]==clubVicePresident[0] && clubPresident[1]==clubVicePresident[1]. . .

Using the strcmp() Function Ex2-11.cpp

Pointers • Pointer variables can be "assigned":int *p1, *p2;p2 = p1; • Assigns one pointer to another • "Make p2 point to where p1 points" • Do not confuse with:*p1 = *p2; • Assigns "value pointed to" by p1, to "valuepointed to" by p2

Pointer Assignments Graphic: Display 10.1 Uses of the Assignment Operator with Pointer Variables

The new Operator • Since pointers can refer to variables… • No "real" need to have a standard identifier • Can dynamically allocate variables • Operator new creates variables • No identifiers to refer to them • Just a pointer! • p1 = new int; • Creates new "nameless" variable, andassigns p1 to "point to" it • Can access with *p1 • Use just like ordinary variable

Basic Pointer Manipulations Example: Display 10.2 Basic Pointer Manipulations (1 of 2)

Basic Pointer Manipulations Example: Display 10.2 Basic Pointer Manipulations (2 of 2) Ex2-12.cpp

Using a Pointer Instead of an Array Name Ex2-13.cpp

Using Pointers to Hold Strings Ex2-14.cpp • Because pointers access computer memory locations, using pointers can be dangerous because you might point to an alter memory locations that you had no intention of altering • A dangling reference is when you delete the value pointed to by one of the pointers, and the other pointer is left without a value

Understanding Arrays and Pointers