Arrays in C++

A

few days after the DSA cohort’s class on arrays, the instructor announced a test contest on the topic.
So, Shiksha reached out to Sagar for a quick revision session.

At Evening

Shiksha: Hey Sagar, thanks for the help! Let’s start arrays from scratch. Please help me understand them deeply.

Sagar: Hello Shiksha, no problem! It’ll be a good revision for me too. Let’s start with the definition.

🧩 Definition

Sagar:
An array in C++ is a collection of elements of the same data type stored at contiguous memory locations.

Think of it like a row of lockers, each storing a value, and all lockers are next to each other in memory.

Example:

int numbers[5] = {10, 20, 30, 40, 50};

Here, numbers is an array of integers with 5 elements.

Shiksha: So all the elements have the same type and are stored one after another in memory?

Sagar: Exactly! That’s what makes arrays efficient for operations like iteration and indexing.

💡 Why Do We Use Arrays?

Shiksha: But why do we even need arrays? Can’t we just use multiple variables?

Sagar: Good question! Imagine you need to store marks of 100 students.
You could create 100 separate variables like mark1, mark2, mark3…, but that’s impractical.

Arrays let you store and manage a large number of values under a single variable name.

Key Benefits:

• Easy Access: You can access elements using an index (marks[i]).

• Efficient Memory Management: Elements are stored contiguously.

• Simplifies Loops: You can iterate through elements easily.

⚙️ How to Use Arrays

Sagar:
There are multiple ways to declare and initialize arrays in C++.

1. Declaration

int arr[5]; // uninitialized array of 5 integers

2. Initialization

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

3. Partial Initialization

int arr[5] = {10, 20}; // remaining elements will be 0

4. Accessing Elements

cout << arr[2]; // prints the 3rd element

5. Iterating Through an Array

for(int i = 0; i < 5; i++) {
 cout << arr[i] << " ";
}

Shiksha: That seems simple enough! But are arrays always of fixed size?

Sagar: In traditional C++, yes. Once declared, the size of a normal array cannot be changed at runtime.
But modern C++ offers alternatives — we’ll talk about those soon.

🔍 Common Methods and Operations with Arrays

Shiksha: I’ve seen some methods used with arrays in tutorials. Are there built-in methods in C++ arrays like in Python?

Sagar: Traditional C-style arrays don’t come with built-in methods.
However, C++ provides Standard Template Library (STL) containers like std::array and std::vector that do.

Let’s split them into two parts:

A. C-Style Array Operations

• Access element: arr[i]

• Find size: sizeof(arr) / sizeof(arr[0])

• Sort: sort(arr, arr + n); (from <algorithm>)

• Search: binary_search(arr, arr + n, value);

• Reverse: reverse(arr, arr + n);

B. std::array Methods (from <array> header)

#include <array>
array<int, 5> arr = {1, 2, 3, 4, 5};

Useful Methods:

• arr.size() → returns the number of elements

• arr.at(i) → safe access with bounds checking

• arr.front() / arr.back() → first and last element

• arr.fill(value) → fills the entire array

• arr.swap(otherArray) → swaps contents with another array

• arr.data() → returns a pointer to the underlying array

⚠️ Limitations of Arrays

Shiksha: Okay, but if arrays are so useful, why do people still prefer vectors?

Sagar: Because arrays have some limitations:

1. Fixed Size: Once defined, the size can’t be changed.

2. No Built-in Bounds Checking: Accessing out-of-range indices causes undefined behavior.

3. Limited Functionality: No dynamic resizing or easy insertion/deletion.

4. Manual Memory Management: Handling large data manually can be error-prone.

🚀 Modern Alternatives to Arrays

Shiksha: So, what’s the modern approach? You mentioned std::array and std::vector earlier.

Sagar: Right! Let’s go over both — they’re part of the STL (Standard Template Library) and provide safer, more flexible solutions.

🧱 1. std::array — Safer Static Arrays

Sagar:
std::array is a wrapper around C-style arrays.
It’s still fixed in size, but it provides extra safety, utility functions, and compatibility with STL algorithms.

Example:

#include <iostream>
#include <array>
#include <algorithm>
using namespace std;

int main() {
 array<int, 5> arr = {5, 3, 4, 1, 2};

 // Access and modify elements
 arr[0] = 10;
 cout << "First Element: " << arr.front() << endl;
 cout << "Last Element: " << arr.back() << endl;

 // Sort the array
 sort(arr.begin(), arr.end());

 // Print all elements
 for (int x : arr) cout << x << " ";
 cout << "\nSize: " << arr.size() << endl;
}

Output:

First Element: 10
Last Element: 2
1 2 3 4 10
Size: 5

Key Takeaway:
std::array is great when you need fixed-size arrays with extra safety and STL compatibility.

🌱 2. std::vector — Dynamic Arrays

Sagar:
Now, std::vector is even more powerful — it’s a dynamic array that can grow or shrink at runtime.
Memory management and resizing are handled automatically.

Example:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main() {
 vector<int> nums = {10, 20, 30};

 nums.push_back(40); // Add element
 nums.pop_back(); // Remove last element
 nums.insert(nums.begin() + 1, 15); // Insert at index 1

 cout << "Vector elements: ";
 for (int x : nums) cout << x << " ";

 cout << "\nSize: " << nums.size() << endl;

 sort(nums.begin(), nums.end());
 cout << "After sorting: ";
 for (int x : nums) cout << x << " ";
}

Output:

Vector elements: 10 15 20 30 
Size: 4
After sorting: 10 15 20 30

Key Takeaway:
Use std::vector when you need resizable arrays and flexibility.
It’s the go-to container in modern C++ for dynamic data storage.

🧠 Use Cases of Arrays

Sagar: Arrays are used in many real-world scenarios:

• Storing data sequences (marks, temperatures, sensor readings)

• Matrix operations in games and simulations

• Buffers in I/O operations

• Static lookup tables

• Algorithm implementation (sorting, searching, hashing, etc.)

⚔️ DSA Approaches and Algorithms Related to Arrays

Shiksha: What about arrays in DSA? I see them in almost every topic!

Sagar: Arrays form the foundation of many data structures and algorithms.

Key Concepts:

1. Searching Algorithms

   • Linear Search

   • Binary Search (for sorted arrays)

2. Sorting Algorithms

   • Bubble Sort

   • Selection Sort

   • Insertion Sort

   • Merge Sort

   • Quick Sort

   • Heap Sort

3. Two-Pointer Technique

   • Pair Sum (arr[i] + arr[j] == k)

   • Removing Duplicates

   • Merging Arrays

4. Sliding Window Technique

   • Maximum Sum Subarray

   • Longest Substring Without Repeating Characters

5. Prefix & Suffix Sum

   • Used for range sum queries and optimization problems

6. Kadane’s Algorithm

   • Finds the maximum subarray sum in O(n) time

7. Arrays as the Base for Advanced Structures

   • Stacks and Queues

   • Heaps

   • Hash Tables

Shiksha: Wow, so arrays are everywhere in DSA!

Sagar: Exactly! Mastering arrays gives you the foundation for almost every other data structure and algorithm.

🧭 Conclusion

Shiksha: So, to summarize:

• Arrays store multiple values of the same type.

• They’re fast and memory-efficient but fixed in size.

• Modern alternatives like std::array and std::vector solve many of their limitations.

• Arrays are the backbone of most DSA concepts.

Sagar: Perfect summary! Once you’re comfortable with arrays, you’ll find it much easier to understand linked lists, stacks, queues, and dynamic programming.

Shiksha: Thanks again, Sagar! I finally feel like I get arrays now.

Sagar: Anytime, Shiksha! Arrays may seem simple, but they’re the building blocks of problem-solving in C++.

📢 If you found this helpful, do like and share!
Follow me for more articles on logic building, C++, and DSA fundamentals.