06 C++ Notes

Arrays

C++ Notes

Declaration and Use

What Is an Array

• Many variables grouped under a single named entity.
• All elements must be of the same type. Mixed types would confuse the compiler, since element sizes would differ.
• Elements are stored right next to each other in memory, both for primitive types and objects. Each value comes immediately after the previous one.
• Each element is accessed through its index, starting from 0.
• An enhanced for-loop can be used for clean iteration over all elements.

Declaration

• int scores[10]; declares an array of size 10, so valid indices run from 0 to 9.
• It contains garbage values at each index until assigned.
• It cannot be resized after declaration.
• Accessing outside the valid index range is undefined behavior and may crash the program.
• After declaration, assignment only uses =: scores[0] = 33;, scores[1] = 45;

Declaration and Assignment Together

Stack Arrays: Size Must Be Compile-Time

• Stack arrays live on the stack. Their size must be known at compile time, not at runtime.
• const is not enough on its own. Only literals or constexpr values work.

Code Example: main.cpp

#include <iostream>

int main() {
    // 1. Declaration (garbage values at each index)
    int scores[10];

    // 2. Assignment after declaration (only = allowed)
    scores[0] = 33;
    scores[1] = 45;

    // 3. Declaration + assignment (brace initialization)
    int arr1[5]{10, 20, 30, 40, 50};

    // 4. Partial brace initialization (remaining elements become 0)
    int arr2[5]{1, 2};

    // 5. Zero-initialized array (recommended, no garbage values)
    int arr3[5]{};

    // 6. Size deduction by compiler (valid but less readable)
    int arr4[]{1, 2, 3};

    // 7. Accessing elements by index
    std::cout << "arr1[0]: " << arr1[0] << "\n";   // prints: 10
    std::cout << "arr1[4]: " << arr1[4] << "\n\n"; // prints: 50

    // 8. Enhanced for loop (read-only iteration)
    std::cout << "arr1 elements: ";
    for (int value : arr1) {
        std::cout << value << " "; // prints: 10 20 30 40 50
    }
    std::cout << "\n";

    // 9. Calculation using enhanced for loop
    int sum{0};
    for (int value : arr1) {
        sum += value;
    }
    std::cout << "Sum of arr1: " << sum << "\n"; // prints: 150

    return 0;
}

Size of Array

• There are two ways to get the number of elements in an array.
• std::size(arr) requires #include <iterator> and C++17 or later. Returns the element count directly.
• sizeof(arr) / sizeof(arr[0]) works in older standards. It divides total bytes by bytes per element to get the count.

Once you have the element count, use it in loops, pass it to functions, or use it as a boundary check.

Code Example: main.cpp

#include <iostream>
#include <iterator>  // required for std::size() in C++17

int main() {
    int arr[]{1, 2, 3};

    std::cout << "std::size(arr):               " << std::size(arr)                        << '\n'; // prints: 3
    std::cout << "sizeof(arr):                  " << sizeof(arr)                           << '\n'; // prints: 12 (3 ints x 4 bytes each)
    std::cout << "sizeof(arr)/sizeof(arr[0]):   " << (sizeof(arr) / sizeof(arr[0])) << '\n'; // prints: 3

    return 0;
}

Array of Char

C-Strings and Null Termination

• A char array can be printed like a string only if it's a proper C-string.
• A proper C-string must end with a null terminator '\0'. This tells C++ where the string ends.
• Without '\0', printing the array causes the program to keep reading memory past the array until it randomly finds a zero byte somewhere, printing garbage characters along the way.

Making a Valid C-String

User Input into Char Arrays

• Input functions like std::cin and std::cin.getline() automatically append '\0'.
• For reading a full line including spaces, use std::cin.getline(variable, size). This is different from std::getline(std::cin, str), which is for std::string, not a char array.
• Always make the array larger than the expected input, to leave room for '\0'.

Size Functions Compared

Code Example: main.cpp

#include <iostream>

int main() {
    // not C-strings: no null terminator, unsafe to print
    char arr1[]{'h','a','s','s','a','n'};      // no '\0'
    char arr2[6]{'h','a','s','s','a','n'};    // size 6, no room for '\0'
    // std::cout << arr1;  // unsafe, prints garbage
    // std::cout << arr2;  // unsafe, prints garbage

    // oversize by 1: brace init zeroes the last element to '\0'
    char arr3[7]{'h','a','s','s','a','n'};
    std::cout << arr3 << '\n'; // prints: hassan

    // string literal: compiler appends '\0' automatically
    char arr4[]{"Hello!"};
    char arr5[]{"Hello, World!"};
    std::cout << arr4 << '\n'; // prints: Hello!
    std::cout << arr5 << '\n'; // prints: Hello, World!

    // user input: getline for char arrays (different from std::getline for std::string)
    char name[20];  // large enough to hold input + '\0'
    std::cout << "Enter your name: ";
    std::cin.getline(name, 20); // reads up to 19 chars, appends '\0' automatically
    std::cout << "You entered: " << name << '\n'; // prints whatever was entered

    return 0;
}

Closing

Arrays are simple until they meet raw memory: fixed size, compile-time only on the stack, and a char array is only safely printable if it's actually null terminated. Next up, pointers, where all of this stops being an implementation detail and becomes the main subject.