Array limitations in Go - Step-by-Step Execution

Concept Flow - Array limitations

Declare array with fixed size

↓

Try to add more elements than size?

Yes→Error: cannot exceed size

No↓

Access elements by index

↓

Try to access index out of range?

Yes→Runtime panic: index out of range

No↓

Array size fixed, cannot resize

↓

END

Arrays have a fixed size set at declaration. You cannot add more elements than this size, and accessing outside the range causes errors.

Execution Sample

Go

package main
func main() {
  var arr [3]int
  arr[0] = 10
  arr[3] = 20
}

This code declares an array of size 3 and tries to assign a value to index 3, which is out of range.

Execution Table

Step	Action	Array State	Index Access	Result/Output
1	Declare array arr of size 3	[0, 0, 0]	N/A	Array created with default zeros
2	Assign arr[0] = 10	[10, 0, 0]	Index 0	Value 10 stored at index 0
3	Assign arr[3] = 20	Error	Index 3	Runtime panic: index out of range

💡 Execution stops due to runtime panic accessing index 3 which is outside array bounds

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3
arr	N/A	[0, 0, 0]	[10, 0, 0]	Runtime panic - no change

Key Moments - 3 Insights

Why can't we add more elements than the declared size of an array?

Arrays in Go have a fixed size set at declaration, so trying to add beyond that size is not allowed and causes errors, as shown in step 3 of the execution_table.

What happens if we try to access an index outside the array range?

Accessing an index outside the array range causes a runtime panic (error) and stops the program, as seen in step 3 where arr[3] causes a panic.

Can we resize an array after it is declared?

No, arrays have a fixed size and cannot be resized. To have resizable collections, slices should be used instead.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of arr after step 2?

A [0, 0, 10]

B [10, 0, 0]

C [0, 10, 0]

D [10, 10, 10]

💡 Hint

Check the 'Array State' column in row for step 2 in execution_table

At which step does the program stop due to an error?

A Step 3

B Step 1

C Step 2

D Program does not stop

💡 Hint

Look at the 'Result/Output' column for each step in execution_table

If we try to assign arr[2] = 30 instead of arr[3], what would happen?

A Compile time error

B Runtime panic error

C Value 30 stored at index 2

D Array size increases

💡 Hint

Refer to variable_tracker and execution_table for valid index assignments

Concept Snapshot

Arrays have fixed size declared at creation.
Cannot add elements beyond this size.
Accessing out-of-range index causes runtime panic.
Arrays cannot be resized.
Use slices for flexible size collections.

Full Transcript

In Go, arrays have a fixed size set when you declare them. For example, var arr [3]int creates an array with exactly 3 elements. You can assign values to indexes 0, 1, and 2. Trying to assign or access index 3 causes a runtime panic because it is out of range. Arrays cannot grow or shrink after creation. If you need a flexible size, use slices instead. This example shows declaring an array, assigning a value to a valid index, and then trying to assign a value to an invalid index which causes the program to stop with an error.

Practice

1. Which statement best describes arrays in Go?

easy

A. Arrays can grow dynamically as elements are added.

B. Arrays automatically resize when elements are removed.

C. Arrays have a fixed size that cannot be changed after creation.

D. Arrays are the same as slices in Go.

Solution

1. Step 1: Understand array size behavior

   In Go, arrays have a fixed size defined when they are created and cannot be resized later.

2. Step 2: Compare with other options

   Options A and C describe dynamic resizing, which arrays do not support. Arrays are the same as slices in Go. is incorrect because arrays and slices are different types.

3. Final Answer:

   Arrays have a fixed size that cannot be changed after creation. -> Option C

4. Quick Check:

   Array size fixed = B [OK]

Hint: Remember: Go arrays have fixed size, slices are flexible [OK]

Common Mistakes:

• Confusing arrays with slices
• Thinking arrays can resize dynamically
• Assuming arrays and slices are identical

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

easy

A. var arr [5]int

B. arr := []int{5}

C. var arr []int = make([]int, 5)

D. arr := [int]5

Solution

1. Step 1: Identify correct array declaration syntax

   In Go, arrays are declared with the size inside square brackets before the type, like [5]int.

2. Step 2: Analyze other options

   arr := []int{5} declares a slice with one element 5, not an array of size 5. var arr []int = make([]int, 5) declares a slice using make, not an array. arr := [int]5 is invalid syntax.

3. Final Answer:

   var arr [5]int -> Option A

4. Quick Check:

   Array syntax = var arr [size]type [OK]

Hint: Array size goes inside brackets before type [OK]

Common Mistakes:

• Using slice syntax instead of array syntax
• Placing size after type
• Using make() for arrays

3. What will be the output of this Go code?

package main
import "fmt"
func main() {
  var arr [3]int
  arr[0] = 10
  arr[1] = 20
  fmt.Println(arr[2])
}

medium

A. 20

B. 10

C. runtime error

D. 0

Solution

1. Step 1: Understand default array values in Go

   Arrays in Go are initialized with zero values for their type. For int, the default is 0.

2. Step 2: Check assigned and unassigned elements

   arr[0] and arr[1] are set to 10 and 20. arr[2] is not assigned, so it remains 0.

3. Final Answer:

   0 -> Option D

4. Quick Check:

   Unassigned int array element = 0 [OK]

Hint: Unassigned int array elements default to 0 [OK]

Common Mistakes:

• Expecting unassigned elements to be garbage or error
• Confusing array with slice behavior
• Assuming runtime error for out-of-range access

4. What is wrong with this Go code snippet?

var arr [3]int
arr = append(arr, 4)

medium

A. The syntax is correct; no error.

B. Arrays cannot be appended to; append works only with slices.

C. append requires a pointer to the array.

D. The array size is too small for append.

Solution

1. Step 1: Understand append function usage

   In Go, append is used only with slices, not arrays.

2. Step 2: Identify error cause

   Trying to append to an array causes a compile-time error because arrays have fixed size and do not support append.

3. Final Answer:

   Arrays cannot be appended to; append works only with slices. -> Option B

4. Quick Check:

   append() works only with slices [OK]

Hint: Use slices, not arrays, with append() [OK]

Common Mistakes:

• Trying to append to arrays
• Assuming append resizes arrays
• Ignoring compile-time errors

5. You need a collection that can grow and shrink dynamically in Go. Which approach correctly solves this limitation of arrays?

hard

A. Use slices instead of arrays for flexible size.

B. Declare a very large array to hold all possible elements.

C. Manually copy array elements to a new larger array when needed.

D. Use a map with integer keys instead of an array.

Solution

1. Step 1: Identify the limitation of arrays

   Arrays have fixed size and cannot grow or shrink dynamically.

2. Step 2: Choose the flexible collection type

   Slices in Go provide dynamic resizing and are the recommended way to handle flexible collections.

3. Step 3: Evaluate other options

   Declare a very large array to hold all possible elements. wastes memory and is inflexible. Manually copy array elements to a new larger array when needed. is manual and error-prone. Use a map with integer keys instead of an array. changes data structure but not necessarily size flexibility.

4. Final Answer:

   Use slices instead of arrays for flexible size. -> Option A

5. Quick Check:

   Dynamic size needs slices = A [OK]

Hint: Slices provide dynamic size, arrays do not [OK]

Common Mistakes:

• Trying to resize arrays manually
• Using large fixed arrays to simulate flexibility
• Confusing maps with dynamic arrays