Introduction to Arrays

• This is chapter 11.
  • We will do 11.1 through 11.3 right now. (One dimensional arrays)
  • We will be back for 11.4 through the end of the chapter later.
  • You should read 11.1 through 11.3 now.
• Just a few notes.
  • Arrays are old, they break the rules.
    • They behave differently than any other structure.
    • They are a major source of programmer error.
    • They are easy to use wrong.
  • Please pay attention.
• An array is a homogeneous collection of data
  • It contains a number of cells or elements
  • These are accessed by index not name.
• We are actually familiar with arrays,
  • Strings are probably implemented as arrays.
  • We can get at the individual characters in a string with an index.
  • word[i]
• With strings, what are the rules for the index?
  • Between 0 and the size of the string -1.
  • What happens if you go out of bounds?
• Motivation
  • An array should probably be used any time you want to name your variables sequentially

  • int memory1, memory2, memory3, memory4;
    PlayerT player1, player2, player3, player4;
             

  • To play a game, for example, you need a nasty if statement.

  • int turn{0};
    
    while (gameNotOver) {
        switch (turn) {
            case 0: TakeTurn(player1); break;
            case 1: TakeTurn(player2); break;
            case 2: TakeTurn(player3); break;
            case 3: TakeTurn(player4); break;
        }
        turn ++
        turn = turn % 4;
    }
             

  • This would become nasty if you had 20 players.
  • With an array we could simplify this

  • PlayerT player[4];
    int turn{0};
    
    while (gameNotOver) {
        TakeTurn(player[turn]);
        turn ++;
        turn %= 4;
    }
             

• Array declaration
  • This is a variable declaration.
  • So it goes at the top of a code block for a function.
  • type identifier[const integer expression];
    • The const integer expression part is very important.
    • You must know the size at compile time.
    • Thus it can not be input at run time.
    • This is part of the standard.
  • Generally, you declare a constant representing the maximum size of the array.
  • Examples

  • const int MAX_PLAYERS{4};
    const int MAX_VALUES{15};
    ...
    // this is bad
    int numbers[10];
    
    // this is better
    int values[MAX_VALUES];
    PlayerT player[MAX_PLAYERS];
    
    // this is not legal
    int size;
    cin >> size;
    char letters[size];
            

  • An array can hold ANY type of item
    • simple types.
    • structures
    • Strings.
• How do we picture an array?
• Array initialization
  • int numbers[MAX_NUMBERS} {1,2,3,4,5};
  • The number of values in {} must be less than or equal to the array size.
  • If it is less, the array is initialized with the given numbers, then the default initialization value (0 for basic types).
• Accessing the elements of an array
  • This is done with an index.
    • The value of the index should be between 0 and the size-1
    • It would be safe to use a size_t
    • It can be done with an enumerated type
  • array[index] can be used on the left hand or right hand side of an expression.
  • Note, the index value MUST be between 0 and the size-1
    • If this is not true, then an array index out of bounds error occurs.
    • The compiler can not detect out of bounds errors
    • The run time system does not detect out of bounds errors.
  • One of two things can happen with an out of bounds errors
    • Your program can crash.
      • Segmentation violation if you are lucky.
      • Corrupt data if you are only partially lucky.
    • Or it can run with broken data if you are not lucky.
• Arrays do not support
  • Direct I/O
  • Direct math.
  • Pass by value, all passes are by pointer
  • Return type of a function.
  • Direct assignment.