1. © Janice Regan, CMPT 128, January 2007 0 CMPT 128: Introduction to Computing Science for Engineering Students Introduction to Arrays

2. © Janice Regan, CMPT 128 2007-2012 1 Simple and Composite Variables  We have studied simple variables  A simple variable describes a single value  A simple variable has an identifier  A simple variable has a type that describes the properties of the value of the variable, the permissible operations for the variable, and the representation of the variable in computer memory  We can also have composite variables  These variables describe a group of values  Arrays: all values in the group have the same type  Structures: different values in the group can have different types

3. © Janice Regan, CMPT 128 2007-2012 2 Composite Variables  composite variables describe a group of values  1 dimensional arrays or variables of a particular type (all entries must have the same type)  multi dimensional arrays or variables of a particular type (all entries must have the same type)  Structures containing groups of variables that may be of different types  Composite variables can  Used as arguments of functions  Used as return values of functions

4. © Janice Regan, CMPT 128 2007-2012 3 One-Dimensional (1-D) Arrays  An array is an indexed data structure  All variables stored in an array are of the same data type  An element of an array is accessed using the array name and an index or subscript  The name of the array is the address of the first element and the subscript is the offset  In C++, the subscripts always start with 0 and increment by 1

5. © Janice Regan, CMPT 128 2007-2012 4 Declaration of a 1-D array  An array is defined using a declaration statement. type array_name[size];  allocates memory for size elements  subscript of first element is 0  subscript of last element is size-1  size must be a constant

6. © Janice Regan, CMPT 128 2007-2012 5 Example Array Declaration in C++ int list[10];  allocates memory for 10 integer variables. Ten adjacent locations in memory are allocated  subscript of first element is 0  subscript of last element is 9  C++ does not perform any bounds checking on arrays list[0] list[1] list[2] list[3] list[4] list[5] list[6] list[7] list[9] list[8]

7. © Janice Regan, CMPT 128 2007-2012 6 Example Array Declaration in C ++ double v2[6];  allocates memory for 6 double variables. Memory is in a single block  subscript of first element is 0  subscript of last element is 5  C++ does not perform any bounds checking on arrays v2[0] v2[1] v2[2] v2[3] v2[4] v2[5]

8. © Janice Regan, CMPT 128 2007-2012 7 Avoid a common problem (1)  C++ does not perform any bounds checking on arrays  This means that you can accidentally change the values of other variables by changing a value you refer to as an element of the array, which is not actually part of the array int myArray[5] = {0}; int count = 6; myArray[5] = 3;

9. © Janice Regan, CMPT 128 2007-2012 8 Avoid a common problem (2) int myArray[5] = {0}; int count = 6; After these declarations memory looks like myArray[5] = 3; After the assignment statement above myArray[0] 0 myArray[1] 0 myArray[2] 0 myArray[3] 0 myArray[4] 0 count 6 myArray[0] 0 myArray[1] 0 myArray[2] 0 myArray[3] 0 myArray[4] 0 count 3

10. © Janice Regan, CMPT 128 2007-2012 9 Avoid a common problem (3)  C++ does not perform any bounds checking on arrays  By changing an element of the array myArray that is outside the memory area allocated to the array we have changed the value of a completely different variable  It is imperative that you be very careful to avoid using elements of the array that are not within the declared array.

11. © Janice Regan, CMPT 128 2007-2012 10 Initializing 1-D Arrays  Arrays can be initialized at the time they are declared.  You can specify individual values for each element of an array // put 0.15 into element 0, 0.25 into element 1 // and 0.3 into element 2 of the array taxrate double taxrate[3] ={0.15, 0.25, 0.3}; // put one character in each element of the array char list[5] = {‘h’,’e’,’l’,’l’,’o’};

12. © Janice Regan, CMPT 128 2007-2012 11 Initializing 1-D Arrays  Declare your array without specifying the size  The length of the array will be determined by the number of elements you initialize // the size of array s is 3 // because 3 elements are initialized int s[ ] = {5,0,-5}; l

13. © Janice Regan, CMPT 128 2007-2012 12 Initializing 1-D Arrays  You can specify individual values for the first n elements of an array.  In this case the remaining unspecified elements will be zero (or equivalent) // values in array taxrate will be // {0.15, 0.25, 0.3, 0.0, 0.0, 0.0} double taxrate[6] ={0.15, 0.25, 0.3};

14. © Janice Regan, CMPT 128 2007-2012 13 Initializing 1-D Arrays  You can specify individual values for the first n elements of an array.  In this case the remaining unspecified elements will be zero (or equivalent) // values in array name will be // {‘J’, ‘a’, ‘n’, ‘i’, ‘c’, ‘e’, ‘\0’, ‘\0’, ‘\0’, ‘\0’} // Two ways to initialize char name[10] ={‘J’, ‘a’, ‘n’, ‘i’, ‘c’, ‘e’}; OR char name[10] = “Janice”;

15. © Janice Regan, CMPT 128 2007-2012 14 Initializing 1-D Arrays  You can specify that all elements of an array should be 0 // assigns zero to all 100 elements // first element is initialized to 0.0 // remaining elements are initialized to 0. double vector[100] = {0.0};

16. © Janice Regan, CMPT 128 2007-2012 15 Initializing 1-D Arrays  Avoid a common error  You cannot specify that all elements of an array should be 1.0 (or any other non-zero value) in a declaration statement, by declaring only the first value // first element is initialized to 1.0 // remaining elements are initialized to 0.0 double vector[100] = {1.0};

17. © Janice Regan, CMPT 128 2007-2012 16 Initializing a 1-D array  You can initialize a simple variable either in the declaration statement, or using separate assignment statements following the declaration statements.  You can also initialize the values of the elements of an array using separate assignment statements following the declaration of the array  A for loop (a counting loop since we know how many elements need initializing) is the most natural way to initialize or otherwise manipulate an array

18. © Janice Regan, CMPT 128 2007-2012 17 Initializing or using 1-D arrays int myinteger[100]; int index; // Initialize each element of array myinteger to 1 for(index=0; index<100; index++) { myinteger[index] = 1; }

19. © Janice Regan, CMPT 128 2007-2012 18 Using a 1-D array for loops are often used to assign values to the elements of an array const int TEN =10.0; double mydouble[TEN] = {0.0}; int index; for(index=0; index<TEN; index++) { list[index] += sqrt( index) * TEN; }

20. © Janice Regan, CMPT 128 2007-2012 19 Putting data into a 1-D Array  Another common way of assigning values to the elements of an array is to read data values from a file directly into the array  Each value read from the file is assigned to a single array element (for example motion[6])  A single value stored in location i in the array time is referred to as time[i]  Note that checks to determine the file was opened correctly and that data was read correctly have been omitted from the example, they should not be omitted from your code

21. © Janice Regan, CMPT 128 2007-2012 20 Array Input from a data file int k; double time[10]; double motion[10]; ifstream sensor3Stream; sensor3Stream.open(“sensor3.txt”); for(k=0; k<10; k++) { sensor3Stream >> time[k] >> motion[k]; }

22. © Janice Regan, CMPT 128 2007-2012 21 Array Input from a data file int k; double time[10]; double motion[10]; FILE *sensor3FilePointer; sensor3FilePointer = fopen(“sensor3.txt”); for(k=0; k<10; k++) { fscanf ( sensor3FilePointer, %lf %lf“, time[k], motion[k] ); }

23. © Janice Regan, CMPT 128 2007-2012 22 Arrays as function parameters  Arrays, or parts of arrays, can be passed as arguments to functions.  An element of an array can be used as a simple variable parameter It can be passed by value or by reference  An entire array can be used as a parameter of a function It can only be passed by reference

24. © Janice Regan, CMPT 128 2007-2012 23 1-D Array elements as parameters  Individual elements of an array can be passed by value as arguments that are of simple variable types.In the illustrated function call  Formal parameter par1 of function donothing has the value of element 2 of the array (array[2])  Formal parameter par2 of function donothing has the value of element 4 of the array (array[4]) void donothing( int par1, int par2 ); int main(void) { int array[5] = {1,2,3,4,5}; donothing(array[2], array[4]); return 0; }

25. © Janice Regan, CMPT 128 2007-2012 24 1-D arrays as parameters  Arrays are always passed to a function by reference  The array name is the address of the first element of the array  The maximum size of the array must be specified at the time the array is declared.  The actual number of array elements that are used will vary, so the actual size of the array is usually passed as another argument

26. © Janice Regan, CMPT 128 2007-2012 25 Function with array argument double max( double array[ ], int actual_size ) { double max; int index; max = 0; for(index = 0; index < actual_size; index++) { if(max < array[index]) { max = array[index]; } return max; }

27. © Janice Regan, CMPT 128 2007-2012 26 Using the function double max( double array[ ], int actual_size ); int main(void) { ifstream exp1; double x[100]; int count=0; exp1.open("inputfile.dat"); while( exp1 >> x[count] && count < 100) { count++; } cout << "Maximum value: “ << max(x, count)<< endl; exp1.close(); return 0; }