Arrays

• Last set of notes we had a general overview of one type of array processing.
  • We knew how many items and we filled the array.
• This time we will
  • Formalize some of the array notation.
  • Look at a different type of processing.
• An array is a homogeneous collection of elements, where each element is accessed by an index
  • The number of elements in the array must be known at compile time.
    • Some compilers don't require this, but it is in the standard.
    • It should be declared as a constant.
• The syntax for declaring an array is

  • type identifier [const int expression] 

• Some examples

  • const size_t MAX_SIZE = 100;
    const size_t MAX_CLASS_SIZE = 40;
    
    int data[20];
    float temps[MAX_SIZE];
    StudentT students[MAX_CLASS_SIZE];
        

• You use an integer, or better yet a size_t to access individual elements
  • The index must be between 0 and the size of the array -1.
  • Array elements are numbered starting at 0 in c/c++
  • There are other languages where this is not true, they go from 1 to size.
  • If you use a number smaller than 0 or larger than size-1 you will have an array out of bounds error.
  • This will sometimes crash your program.
  • Unfortunately sometimes it will not crash your program.
  • Take a look at oob.cpp
• Array initialization
  • A better reference
  • You can use an initializer list.

  • int ary1[5] = {3, 5, 7, 9, 11}; 

    • The size of the list in {} must be less than or equal to the max array size.
    • Any missing values are filled in with 0.
  • Uniform Initialization is a c++11 feature.
    • Same as above but ski p the =
    • But does tighter type checking
• Look at initArray.cpp
• You can not
  • Copy arrays directly, this does not do what you think it does.
  • Compare arrays directly, this does not do what you think it does.
  • Do math on arrays directly, this does not do what you think it does.
  • Do I/O on arrays directly, ...
  • Return arrays as the return value of a function.
• Arrays are passed by reference only.
  • This is for historical reasons.
  • Arrays can be very big.
  • Pass by value would make a copy of the data.
  • So Ritchie decided that they were pass by reference.
  • But no & needed.
  • But you can add the keyword const.
• Look at aryCant.cpp
• One method for cracking ciphers is to do a frequency analysis of the letters in the text.
  • Just count the number of times each letter occurs, then look at a know. letter frequency distribution.
  • This will allow you to crack most simple shift ciphers if the message is large enough.
  • Look at frequency.cpp