Introduction to Arrays

Test 1, Next Friday 2/23.
- review of c++,
- strings,
- recursion.
Read chapter 11 section 1.
What if we wanted to store all of the palindromes that were in a file to allow a user to search for their favorites?
- Assume we know that there are 100 palindromes in a file.
- We could make 100 variables, and somehow deal with all of them
- ```
string pal1, pal2, pal3, ...
getline(inFile, pal1);
getline(inFile, pal2);
...
	  
```
- Seem like a good idea?
  - Just reading in the code would involve 100 lines.
  - Checking to see if the palindrome matched an input string would be bad.
- You know a better way from CSCI125 (I hope)... Arrays.
Book Definition: An Array is a structured collection of components, all of the same type, that is given a single name. Each component, or array element, is accessed by an index that indicates the components position within the collection.
My Definition: A homogeneous collection of elements, which permit constant time access.
- They are all the same type.
- It takes the same amount of time to get to any element.
They are an ADT but we will hold off on that until later.
An array can hold any type of element, including other arrays
- But don't go there for now.
An array must be declared with a known size at compile time.
- g++ actually lets you get away with run time allocation
- But the standard does not,
- And you may not do this.
- No, "But it works". This is the standard.
Declaring arrays
- syntax 1: type identifier[const int expression];
- syntax 2: type identifier[] = { a, b, c, ...}; where a,b,c ... are of the given type.
- ```
// an array of 10 integers
int numbers[10];

// an array of 20 floats
const int MAX_GRADES = 20;
...

float grades[MAX_GRADES];

// a array of strings
const int MAX_PHRASE_COUNT = 1000;
...
string phrases[MAX_PHRASE_COUNT];

//an array of characters
char vowels[] = {'a','e','i','o','u'};
```
- The last one is somewhat problematic
  - You could also declare char vowels[5] = {'a','e','i','o','u'};
  - But this would have problems if you added or deleted something.
- Note, we are allocating a bunch of memory very quickly.
Indexing is as we discussed with strings.
- Use the [] operator.
- You need to make sure that the 0 ≤ index < size.
- The problem is, arrays are from C and there is no size operator.
- There is a function, sizeof which might be helpful some times
  - For a variable, it will return the size of that variable in bytes.
  - So the size of an array divided by the size of an array element is the number of elements in the array.
  - This trick only works in the function where the array is declared.
    - There is some strange behavior when passing arrays to functions
    - and this trick will not work in a function where an array is passed as a parameter.
  - See simple.C
- So it is conventional, when you deal with an array you have two additional values.
  - The maximum size, this should be a constant.
  - The actual number of elements, this should be a variable.
An array index out of bounds error or out of bounds array index is where an index has a value of less than 0 or greater than the size.

For the most part, arrays follow the pattern for other types BUT

There is no assignment operator to copy arrays

int a[10],b[10]

// this will compile
// but it does not do what you think it does.
a = b;

There are no array comparison operators

int a[10],b[10]

// this will compile
// but it does not do what you think it does.
a == b;

There is no direct I/O on arrays

int a[10],b[10]

// this will compile
// but it does not do what you think it does.
cout <<a

Arrays are ALWAYS passed by reference.

// this will compile
// but a is passed to param by reference 
void Foo(int param[10]);
...
int a[10]
Foo(a);

Arrays may not be returned from a function.

// this will not compile
int[10] Foo();

Simple array processing
- We have seen it, just step through the array.
- Print out the letters in vowels
- Generate random numbers and stick them in numbers.
- Print out the values in numbers.
- find the max and min of numbers.