Lecture 10: Two-Dimensional Arrays and std::vector

## Two-dimensional array and vector syntax

~~~cpp
<T> <name>[<rows>][<cols>];       // one bound per dimension
<name>[<r>][<c>]                  // needs 0 <= <r> < <rows> AND 0 <= <c> < <cols>

for (int <r> = 0; <r> < <rows>; ++<r>)
    for (int <c> = 0; <c> < <cols>; ++<c>)
        // visits <name>[<r>][<c>] exactly once

std::vector<T> <name>;                    // size 0
std::vector<T> <name>(<count>, <value>);  // <count> copies of <value>

<name>.push_back(<value>);   // appends, size grows by one
<name>.size()                // the current number of elements
<name>[<i>]                  // unchecked, like an array
<name>.at(<i>)               // throws std::out_of_range if the index is invalid
~~~

| Part | Meaning |
| --- | --- |
| <code>T</code> | The element type. Write the real type: <code>int</code>, <code>double</code>, <code>std::string</code>. |
| <code>rows</code>, <code>cols</code> | Independent bounds. Each index must be checked against its own dimension, not against the other. |
| loop nesting order | With the row loop outside, each row is traversed in turn. Reversing the loops with appropriate bounds changes traversal order, not matrix dimensions. |
| <code>size()</code> | Number of elements; valid indices range from 0 up to, but excluding, this value. An empty vector has no valid element index. |
| <code>[]</code> vs <code>at()</code> | Both access an element. In C++17, <code>[]</code> is unchecked; <code>at()</code> checks the index and throws <code>std::out_of_range</code> if it is invalid. |

In a built-in array declaration such as <code>int image[2][3]</code>, both bounds are positive compile-time constants. A vector can change size during execution, but every element access must still use a valid index.

Step 1: A fixed-size array holds a known number of readings

#include <iostream>

int main() {
    int readings[3]{10, 20, 30};
    for (int i = 0; i < 3; ++i) {
        std::cout << readings[i] << ' ';
    }
}

Three readings, three slots, one loop bound. Everything is fixed before the program runs. int readings[3] = {10, 20, 30}; (copy-list-initialization, with =) gives the same array; the two forms differ only for class types with explicit constructors, which we meet when we study classes and constructors.

Step 2: Add a dimension — rows and columns need two indices

#include <iostream>

int main() {
    int image[2][3]{{10, 20, 30}, {40, 50, 60}};
    for (int row = 0; row < 2; ++row) {
        for (int col = 0; col < 3; ++col) {
            std::cout << image[row][col] << ' ';
        }
        std::cout << '\n';
    }
}

Added: a second bound and an inner loop. Each index is checked against its own dimension.

Step 3: Delete the fixed bound — std::vector grows as input arrives

#include <iostream>
#include <vector>

int main() {
    std::vector<int> readings;
    int value;
    while (std::cin >> value) {
        readings.push_back(value);
    }
    for (std::size_t i = 0; i < readings.size(); ++i) {
        std::cout << readings[i] << ' ';
    }
}

Deleted: the literal 3. The count is now readings.size(), known only at run time.

Step 4: Swap [] for at() — make an invalid index fail loudly

#include <iostream>
#include <vector>

int main() {
    std::vector<int> readings;
    int value;
    while (std::cin >> value) {
        readings.push_back(value);
    }
    if (readings.empty()) {
        std::cout << "no readings\n";
        return 0;
    }
    for (std::size_t i = 0; i < readings.size(); ++i) {
        std::cout << readings.at(i) << ' ';
    }
}

Added: an empty check and at(i). An empty vector has no valid index; at throws instead of causing undefined behavior.

Step 5: Nest vectors — rows may differ in length

#include <iostream>
#include <vector>

int main() {
    std::vector<std::vector<int>> scores{{8, 7, 9}, {6, 10}};
    for (const auto& row : scores) {
        int total = 0;
        for (int score : row) {
            total += score;
        }
        std::cout << total << '\n';
    }
}

Replaced: the flat vector with a vector of rows. Each row is traversed with its own size, so a ragged shape is safe.

## Memory is a numbered strip; a vector keeps its elements elsewhere

## An array name is the address of its first element

Elements sit one after another. The name <code>a</code> converts to the address of <code>a[0]</code>; element <code>i</code> is <code>i × sizeof(int)</code> bytes further on — an index is an offset.