Why aren't built-in arrays safe?

Question

The book C++ Primer, 5th edition by Stanley B. Lippman (ISBN 0-321-71411-3/978-0-321-71411-4) mentions:

An [std::]array is a safer, easier-to-use alternative to built-in arrays.

What's wrong with built-in arrays?

Answer 1

1. A built-in array is a contiguous block of bytes, usually on the stack. You really have no decent way to keep useful information about the array, its boundaries or its state. std::array keeps this information.

2. Built-in arrays are decayed into pointers when passed from/to functions. This may cause:

   • When passing a built-in array, you pass a raw pointer. A pointer doesn't keep any information about the size of the array. You will have to pass along the size of the array and thus uglify the code. std::array can be passed as reference, copy or move.

   • There is no way of returning a built-in array, you will eventually return a pointer to local variable if the array was declared in that function scope. std::array can be returned safely, because it's an object and its lifetime is managed automatically.

3. You can't really do useful stuff on built-in arrays such as assigning, moving or copying them. You'll end writing a customized function for each built-in array (possibly using templates). std::array can be assigned.

4. By accessing an element which is out of the array boundaries, you are triggering undefined behaviour. std::array::at will preform boundary checking and throw a regular C++ exception if the check fails.

5. Better readability: built in arrays involves pointers arithmetic. std::array implements useful functions like front, back, begin and end to avoid that.

Let's say I want to sort a built-in array, the code could look like:

int arr[7] = {/*...*/}; std::sort(arr, arr+7); 

This is not the most robust code ever. By changing 7 to a different number, the code breaks.

With std::array:

std::array<int,7> arr{/*...*/}; std::sort(arr.begin(), arr.end()); 

The code is much more robust and flexible.

Just to make things clear, built-in arrays can sometimes be easier. For example, many Windows as well as UNIX API functions/syscalls require some (small) buffers to fill with data. I wouldn't go with the overhead of std::array instead of a simple char[MAX_PATH] that I may be using.