Array Declaration and Initialization in DSA C++ - Execution Trace

Concept Flow - Array Declaration and Initialization

Start

↓

Declare array variable

↓

Allocate memory for fixed size

↓

Initialize elements (optional)

↓

Array ready to use

↓

Access elements by index

The flow shows declaring an array variable, allocating fixed memory, optionally initializing elements, and then accessing elements by index.

Execution Sample

DSA C++

int arr[5];
arr[0] = 10;
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;

This code declares an integer array of size 5 and initializes each element with a value.

Execution Table

Step	Operation	Array State	Pointer Changes	Visual State
1	Declare array int arr[5]	[?, ?, ?, ?, ?]	arr points to base address	[?] [?] [?] [?] [?]
2	Initialize arr[0] = 10	[10, ?, ?, ?, ?]	arr + 0 set to 10	[10] [?] [?] [?] [?]
3	Initialize arr[1] = 20	[10, 20, ?, ?, ?]	arr + 1 set to 20	[10] [20] [?] [?] [?]
4	Initialize arr[2] = 30	[10, 20, 30, ?, ?]	arr + 2 set to 30	[10] [20] [30] [?] [?]
5	Initialize arr[3] = 40	[10, 20, 30, 40, ?]	arr + 3 set to 40	[10] [20] [30] [40] [?]
6	Initialize arr[4] = 50	[10, 20, 30, 40, 50]	arr + 4 set to 50	[10] [20] [30] [40] [50]
7	Access arr[2]	[10, 20, 30, 40, 50]	Read value 30	[10] [20] [30] [40] [50]
8	End	[10, 20, 30, 40, 50]	No changes	[10] [20] [30] [40] [50]

💡 All elements initialized and accessed; execution ends.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	After 5	Final
arr[0]	?	10	10	10	10	10	10
arr[1]	?	?	20	20	20	20	20
arr[2]	?	?	?	30	30	30	30
arr[3]	?	?	?	?	40	40	40
arr[4]	?	?	?	?	?	50	50

Key Moments - 3 Insights

Why do the initial array elements show '?' before initialization?

Because in C++, declaring an array like int arr[5]; does not automatically set values. Memory is allocated but contains garbage until explicitly initialized (see steps 1 and 2 in execution_table).

Why do we access elements by index starting at 0?

Array indexing in C++ starts at 0, so arr[0] is the first element. This is shown in the visual state where arr + 0 points to the first element (step 2).

What happens if we try to access arr[5]?

Accessing arr[5] is out of bounds since the array size is 5 (indices 0 to 4). This leads to undefined behavior and is not shown in the execution_table because it is invalid.

Visual Quiz - 3 Questions

Look at the execution_table at step 4, what is the value of arr[2]?

A 30

B ?

C 20

D 40

💡 Hint

Check the 'Array State' column at step 4 in execution_table.

At which step does arr[4] get its value assigned?

A Step 3

B Step 6

C Step 5

D Step 2

💡 Hint

Look for the operation that sets arr[4] in execution_table.

If we skip initializing arr[1], what would be its value after step 6?

A 20

B 0

C ?

D 50

💡 Hint

Uninitialized elements remain '?' as shown in variable_tracker.

Concept Snapshot

Array Declaration and Initialization in C++:
- Declare with fixed size: int arr[5];
- Memory allocated but uninitialized (contains garbage '?')
- Initialize elements by index: arr[0] = value;
- Access elements by zero-based index: arr[0], arr[1], ...
- Out-of-bounds access is invalid and unsafe.

Full Transcript

This visual trace shows how an array is declared and initialized in C++. First, the array variable is declared with a fixed size, allocating memory but leaving elements uninitialized (shown as '?'). Then, each element is assigned a value by its index, updating the array state step-by-step. Accessing elements uses zero-based indexing. The trace also highlights common beginner confusions such as uninitialized values and indexing rules.

Practice

1. Which of the following is the correct way to declare an integer array of size 5 in C++?

easy

A. int arr = new int[5];

B. array<int> arr(5);

C. int arr[5];

D. int arr();

Solution

1. Step 1: Understand basic array declaration syntax

   In C++, to declare a fixed-size array, we use the syntax type name[size];.

2. Step 2: Check each option

   int arr[5]; uses int arr[5]; which is the correct syntax for declaring an integer array of size 5. int arr = new int[5]; uses dynamic allocation syntax which is valid but not a declaration. array<int> arr(5); uses a non-standard syntax. int arr(); declares a function, not an array.

3. Final Answer:

   int arr[5]; -> Option C

4. Quick Check:

   Array declaration = int arr[5]; [OK]

Hint: Use type name[size]; for fixed-size arrays [OK]

Common Mistakes:

• Using parentheses instead of square brackets
• Confusing dynamic allocation with declaration
• Using non-standard syntax

2. Which of the following is the correct syntax to initialize an array of 3 integers with values 1, 2, and 3 in C++?

easy

A. int arr[3] = {1, 2, 3};

B. int arr = {1, 2, 3};

C. int arr[3] = (1, 2, 3);

D. int arr[3] = [1, 2, 3];

Solution

1. Step 1: Recall array initialization syntax

   In C++, arrays are initialized using curly braces with values separated by commas, like int arr[size] = {values};.

2. Step 2: Evaluate each option

   int arr[3] = {1, 2, 3}; correctly uses curly braces with values. int arr = {1, 2, 3}; misses the size in declaration. int arr[3] = (1, 2, 3); uses parentheses which is invalid. int arr[3] = [1, 2, 3]; uses square brackets which is incorrect for initialization.

3. Final Answer:

   int arr[3] = {1, 2, 3}; -> Option A

4. Quick Check:

   Array init uses curly braces = int arr[3] = {1, 2, 3}; [OK]

Hint: Initialize arrays with curly braces and commas [OK]

Common Mistakes:

• Omitting array size in declaration
• Using parentheses or square brackets for initialization
• Missing commas between values

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

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

medium

A. 10 20 0 20

B. 10 20 0 0

C. 10 20 10 20

D. 10 20 garbage garbage

Solution

1. Step 1: Understand partial array initialization

   When an array is partially initialized, the remaining elements are set to zero automatically in C++.

2. Step 2: Trace the loop output

   The first two elements are 10 and 20 as given. The last two elements are 0 by default. So the output prints: 10 20 0 0

3. Final Answer:

   10 20 0 0 -> Option B

4. Quick Check:

   Partial init fills rest with 0 = 10 20 0 0 [OK]

Hint: Uninitialized array elements default to 0 if partially initialized [OK]

Common Mistakes:

• Assuming uninitialized elements have garbage values
• Confusing partial initialization with full initialization
• Misreading loop bounds

4. Identify the error in the following C++ code snippet:

int arr[];
arr = {1, 2, 3};

medium

A. Array size must be specified during declaration

B. Array elements must be initialized with parentheses

C. Missing semicolon after array declaration

D. Cannot assign values to array after declaration like this

Solution

1. Step 1: Check array declaration rules

   In C++, arrays must have size specified or be initialized at declaration. Here, int arr[]; is invalid because size or initializer is missing.

2. Step 2: Understand assignment to arrays

   Arrays cannot be assigned values after declaration using = { ... }. This syntax is invalid. Initialization must happen at declaration.

3. Final Answer:

   Cannot assign values to array after declaration like this -> Option D

4. Quick Check:

   Arrays can't be assigned with braces after declaration [OK]

Hint: Initialize arrays only at declaration, no later assignment [OK]

Common Mistakes:

• Trying to assign array values after declaration
• Omitting array size without initializer
• Confusing array assignment with pointer assignment

5. You want to declare and initialize a 2D integer array with 2 rows and 3 columns, where all elements are zero. Which is the best way to do this in C++?

hard

A. int arr[2][3] = {0};

B. int arr[2][3] = {{0,0,0},{0,0,0}};

C. int arr[2][3]; memset(arr, 0, sizeof(arr));

D. int arr[2][3] = {0, 0, 0, 0, 0, 0};

Solution

1. Step 1: Understand zero initialization of multi-dimensional arrays

   In C++, initializing the first element to zero with {0} sets all elements to zero by default.

2. Step 2: Compare options for simplicity and correctness

   int arr[2][3] = {0}; uses {0} which zero-initializes all elements. int arr[2][3] = {{0,0,0},{0,0,0}}; explicitly lists zeros but is longer. int arr[2][3]; memset(arr, 0, sizeof(arr)); uses memset which works but is less clean. int arr[2][3] = {0, 0, 0, 0, 0, 0}; lists all zeros but is verbose.

3. Final Answer:

   int arr[2][3] = {0}; -> Option A

4. Quick Check:

   Use {0} to zero initialize entire array [OK]

Hint: Use {0} to zero initialize all elements in arrays [OK]

Common Mistakes:

• Not knowing {0} zero initializes entire array
• Using memset without including <cstring>
• Writing verbose initializers unnecessarily