Array size and bounds in C++ - Step-by-Step Execution

Concept Flow - Array size and bounds

Declare array with fixed size

↓

Access elements by index

↓

Check if index < size?

No→Error: Out of bounds

Yes↓

Read or write element

↓

Repeat or end

This flow shows how arrays have a fixed size and how accessing elements must stay within valid index bounds to avoid errors.

Execution Sample

C++

int arr[3] = {10, 20, 30};
int x = arr[1];
int y = arr[3];

This code declares an array of size 3, accesses a valid element at index 1, then tries to access an invalid element at index 3.

Execution Table

Step	Action	Index Accessed	Index Valid?	Result	Notes
1	Declare array	-	-	arr = {10, 20, 30}	Array created with size 3
2	Access arr[1]	1	Yes	Value = 20	Index 1 is within bounds (0 to 2)
3	Access arr[3]	3	No	Undefined behavior	Index 3 is out of bounds (max index 2)

💡 Execution stops or causes error when accessing index 3 because it is outside array bounds.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3
arr	undefined	{10, 20, 30}	{10, 20, 30}	{10, 20, 30}
x	undefined	undefined	20	20
y	undefined	undefined	undefined	undefined (invalid access)

Key Moments - 2 Insights

Why is accessing arr[3] a problem?

Because the array size is 3, valid indices are 0, 1, and 2. Index 3 is outside this range, causing undefined behavior as shown in step 3 of the execution table.

Does declaring an array set all elements automatically?

No, only the elements you initialize are set. In this example, all three elements are initialized. Uninitialized elements can contain garbage values.

Visual Quiz - 3 Questions

Look at the execution table, what value is stored in x after step 2?

A 10

B 30

C 20

D Undefined

💡 Hint

Check the 'Result' column at step 2 in the execution table.

At which step does the program try to access an invalid index?

A Step 2

B Step 3

C Step 1

D No invalid access

💡 Hint

Look at the 'Index Valid?' column in the execution table.

If the array size was changed to 4, what would happen at step 3?

A Access is valid and returns a value

B Access is still invalid

C Compilation error

D Array size does not affect access

💡 Hint

Refer to the 'Index Valid?' logic and array size in the concept flow.

Concept Snapshot

Array size is fixed at declaration.
Valid indices are from 0 to size-1.
Accessing outside this range causes undefined behavior.
Always check index before accessing array elements.
Example: int arr[3]; valid indices: 0,1,2.

Full Transcript

This lesson shows how arrays in C++ have a fixed size and how accessing elements must be done within valid index bounds. The example declares an array of size 3 with elements 10, 20, and 30. Accessing arr[1] is valid and returns 20. Accessing arr[3] is invalid because the maximum index is 2, leading to undefined behavior. The execution table traces these steps clearly. Remember, always keep array accesses within bounds to avoid errors.

Practice

1. What is the valid range of indexes for an array declared as int arr[10]; in C++?

easy

A. 1 to 9

B. 1 to 10

C. 0 to 10

D. 0 to 9

Solution

1. Step 1: Understand array size declaration

   The array arr is declared with size 10, meaning it holds 10 elements.

2. Step 2: Determine valid index range

   In C++, array indexing starts at 0, so valid indexes are from 0 up to size-1, which is 9.

3. Final Answer:

   0 to 9 -> Option D

4. Quick Check:

   Array size 10 means indexes 0 to 9 [OK]

Hint: Array indexes start at 0 and end at size minus 1 [OK]

Common Mistakes:

• Thinking indexes start at 1
• Including size as a valid index
• Confusing size with last index

2. Which of the following is the correct way to declare an array of 5 integers in C++?

easy

A. int arr[5];

B. int arr = 5;

C. int arr(5);

D. int arr{5};

Solution

1. Step 1: Review array declaration syntax

   In C++, arrays are declared using square brackets with the size inside, like int arr[5];.

2. Step 2: Check each option

   int arr(5); uses parentheses which is invalid for arrays. int arr = 5; assigns an int, not an array. int arr{5}; uses brace initialization but without specifying size properly.

3. Final Answer:

   int arr[5]; -> Option A

4. Quick Check:

   Array declaration uses square brackets [OK]

Hint: Use square brackets [] to declare array size [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Assigning a single int instead of array
• Confusing brace initialization with size

3. What will be the output of the following code?

int arr[3] = {10, 20, 30};
std::cout << arr[3] << std::endl;

medium

A. Undefined behavior (may print garbage or crash)

B. 0

C. 30

D. Compilation error

Solution

1. Step 1: Identify array size and index used

   The array has size 3, valid indexes are 0, 1, 2. The code accesses arr[3], which is out of bounds.

2. Step 2: Understand consequences of out-of-bounds access

   Accessing outside array bounds in C++ causes undefined behavior. It may print garbage, crash, or behave unpredictably.

3. Final Answer:

   Undefined behavior (may print garbage or crash) -> Option A

4. Quick Check:

   Out-of-bounds access causes undefined behavior [OK]

Hint: Access only indexes 0 to size-1 to avoid undefined behavior [OK]

Common Mistakes:

• Assuming arr[3] returns last element
• Expecting zero instead of garbage
• Thinking compiler catches out-of-bounds

4. Identify the error in the following code snippet:

int arr[4] = {1, 2, 3, 4};
for (int i = 0; i <= 4; i++) {
    std::cout << arr[i] << " ";
}

medium

A. Array size should be 5

B. Initialization of array is incorrect

C. Loop condition should be i < 4, not i <= 4

D. No error, code runs fine

Solution

1. Step 1: Analyze loop bounds

   The loop runs from i = 0 to i = 4 inclusive, so it tries to access arr[4].

2. Step 2: Check array size and valid indexes

   Array size is 4, valid indexes are 0 to 3. Accessing arr[4] is out of bounds and causes undefined behavior.

3. Final Answer:

   Loop condition should be i < 4, not i <= 4 -> Option C

4. Quick Check:

   Loop must use i < size to avoid out-of-bounds [OK]

Hint: Use < size, not <= size, in loops over arrays [OK]

Common Mistakes:

• Using <= instead of < in loop condition
• Increasing array size unnecessarily
• Ignoring out-of-bounds access

5. You want to create a function that sums all elements of an integer array passed along with its size. Which of the following function signatures correctly allows safe access to the array elements without causing out-of-bounds errors?

hard

A. int sumArray(int arr[10]);

B. int sumArray(int arr[], int size);

C. int sumArray(int* arr);

D. int sumArray(int arr[]);

Solution

1. Step 1: Understand function parameter requirements

   To safely access array elements, the function must know the array size to avoid out-of-bounds access.

2. Step 2: Evaluate each signature

   int sumArray(int arr[], int size); passes both array and size, allowing safe iteration. int sumArray(int arr[10]); fixes size to 10, which is unsafe if actual size differs. int sumArray(int* arr); passes pointer without size, unsafe. int sumArray(int arr[]); passes array without size, unsafe.

3. Final Answer:

   int sumArray(int arr[], int size); -> Option B

4. Quick Check:

   Pass array and size to avoid out-of-bounds [OK]

Hint: Always pass array size with array to functions [OK]

Common Mistakes:

• Assuming fixed size in function parameter
• Not passing size leads to unsafe access
• Using pointer without size information