std::array vs C-style Arrays

std::array is a container provided by the C++ Standard Library that encapsulates a fixed-size array. It provides several advantages over traditional C-style arrays:

1. Size and Type Information: With a C-style array, the size and type of the array can decay when passed to a function. This means the function doesn't know the size of the array, which can lead to errors. std::array, on the other hand, preserves its size and type information.
2. Bounds Checking: std::array provides an at() function for accessing elements, which performs bounds checking and throws an exception if the index is out of range. C-style arrays do not have built-in bounds checking.
3. STL Compatibility: std::array is compatible with the Standard Template Library (STL). This means you can use STL algorithms (like std::sort, std::find, etc.) directly on a std::array. With C-style arrays, you would need to pass pointers and sizes to these algorithms.
4. Member Functions: std::array provides member functions like size(), empty(), front(), back(), etc., which make it easier to work with the array. C-style arrays don't have these member functions.

Here's an example that illustrates some of these differences:

1#include <array>
2#include <iostream>
3#include <algorithm>
4
5void PrintArray(const std::array<int, 5>& arr) {
6  std::cout << "Size: " << arr.size() << '\n';
7
8  for (int i : arr) {
9    std::cout << i << ' ';
10  }
11  std::cout << '\n';
12}
13
14int main() {
15  std::array<int, 5> MyArray{5, 2, 3, 1, 4};
16
17  std::sort(MyArray.begin(), MyArray.end());
18
19  PrintArray(MyArray);
20}

1Size: 5
21 2 3 4 5

In this example:

• The PrintArray function knows the size of the array because it's encoded in the type of arr.
• We can directly sort MyArray using std::sort because std::array provides begin() and end() functions.

However, C-style arrays do have one advantage: they can be initialized from string literals, which is not possible with std::array.

Despite this, in most cases, std::array is a safer and more convenient choice than C-style arrays.