Fixed std::array in C++

Introduction

Introduced in C++11, std::array is part of the Standard Template Library (STL) and provides a fixed-size array with several advantages over traditional C-style arrays.

Basics of std::array

Declaration and initialization:

In C++, std::array is defined in the <array> header. The syntax for declaring an array is straightforward:

#include <array>

std::array<int, 5> myArray; // Declare an integer array of size 5

Here, int is the type of elements in the array, and 5 is the size of the array. Unlike C-style arrays, the size of std::array is part of its type, making it more robust and less error-prone.

Initialization can be done in various ways, similar to other containers in the STL:

std::array<int, 5> myArray = {1, 2, 3, 4, 5}; // Initialize with values.

Accessing Elements:

Elements in a std::array can be accessed using the subscript operator ([]) or the at() member function:

int value1 = myArray[2]; // Access the third element
int value2 = myArray.at(2); // Same as above

Size and Capacity:

Unlike C-style arrays, std::array retains information about its size, which can be obtained using the size() member function.

The size() member function returns the size of the array:

std::size_t arraySize = myArray.size();

Since std::array has a fixed size, there's no concept of capacity like in dynamic containers such as std::vector.

Advantages of std::array

Safety and Bound Checking:

One of the primary advantages of std::array over C-style arrays is that it performs bounds checking. If you attempt to access an element beyond the array's boundaries, a runtime error will occur. This help prevent common error associated with C-style arrays, like buffer overflows.

Iterators:

std::array supports iterators, allowing you to traverse its elements using a range-based for loop or standard iterator syntax:

for (const auto& element : myArray) {
    // Process each element
}

Standard Library Algorithms:

Since std::array adheres to the STL interface, you can use various algorithms from the `<algorithm> header directly on it. Sorting, searching, and other operations become more convenient:

#include <algorithm>

std::sort(myArray.begin(), myArray.end());

When to Use std::array

1. Compile-Time Size: If the size of the array is known at compile time and won't change during runtime, std::array is a better choice than C-style arrays.
2. Safety Requirement: If safety is a concern and you want automatic bound checking, std::array provides a safer alternative to C-style arrays.
3. STL Compatibility: When working with other STL containers and algorithms, using std::array ensures consistency and compatibility.

Important functions

size()

Unlike C-style

at():

The at() member function provides a way to access elements with bounds checking. If the index is out of elements with bounds checking. If the index is out of range, an std::out_of_range exception is thrown:

try {
	int value = myArray.at(6);
} catch (const std::out_of_range& e) {
	// Handle out-of-range access
}

fill()

The fill() member function sets all elements in the array to a specified value.

myArray.fill(0);

front() and back()

These functions provide direct access to the first and last elements of the array, respectively.

int firstElement = myArray.front();
int lastElement = myArray.back();

data()

The data() member function returns a pointer to the underlying array, allowing interoperability with functions that expect raw arrays.

int* rawPointer = myArray.data();

Iterators

std::array supports iterators, facilitating traversal through the elements.

for (auto it = myArray.begin(); it != myArray.end(); ++i) {
	// Process each element.
}