It actually IS possible to make access of the array member undefined behavior. Just state in the documentation that the name of the member is unspecified and its use undefined 😉

Maybe nitpicky but writing a c array like 'S s[5]' DOES initialize the array. It always calls the default constructor of every element in the array. It just happens to be that the default constructor of int isn't doing anything.

Just a quick reminder that `std::size_t` is defined in <cstddef> along with its signed counterpart `std::ptrdiff_t`. The <cstdint> header is only for fixed integer types like `std::int8_t`, `std::uint32_t`, etc.

Also you should include <fmt/core.h> in order to use `fmt::print` and not <fmt/format.h> header.

People have been trying to use string literals as template arguments and failed. I just use std::to_array to convert string literal to std::array and use the std::array as template argument. You have to ignore the terminating null, but I use std::make_index_sequence and some template magic to remove the null from the std::array.

One thing that infuriates me about std::array is that unlike std::vector "capacity" and "size" are the same value. Thus if you have situations like this:

std::array<double, 10'000'000> arr;
std::fill(arr.begin(), arr.end(), 0.0);

//Imagine some type of user input like a stream from a signal of some kind here.
arr[0] = 1.1;
arr[1] = 45767.98;
arr[2] = 2.33;
//…
arr[100'000] = 12.97;

//We've got an array of 10 million elements but have only used 100 thousand.

for(size_t i = 0uz; i < arr.size(); ++i)
{
arr[i] = std::sin(arr[i]) * std::tan(arr[i]) / 2.0;
//9.9 Mil unnecessary calculations that could fill the unused part of our array with a bunch of NaN and -Nan or result in a ton of DIVIDE_BY_ZERO exceptions being generated and thrown.
}

In order to fix this I usually wrap std::array in a struct like this:

template<typename T, std::size_t Size>
struct fixed_array{
std::array<T, Size> data;
std::size_t in_use_size = 0uz; //TO-DO Increment this when a new value is added, decrement when a value is removed ONLY from the end
};

Which usually necessitates adding operator overloads and wrapper functions for everything std::array does so that the code isn't confusing or even more infuriating to use.

This issue makes using std::array a lot of work. I can't wait for boost's static_vector to get into the standard so we can have a stack allocated array with different variables for size and capacity.

What compiler parameter shows the uninitialized error at 3:20? I'm not getting it :/

Would've been neat to touch on the specialization stuff for 0-lengthed arrays that are necessary without a compiler extension

It would be nice to see something like a same_for_const keyword/modifier that would just make the const version of functions for you.

Nice peek under the hood, should be convincing that using std::array instead of C array won't necessarily add much or any runtime or storage cost in normal usage (just a little bit of compilation time; and at() can throw but use -fno-exceptions if you are worried about that, or don't make out of bounds accesses!) but adds a better and safer interface.

8:05 since constexpr is implicitly inline, size() == 0 turns into _Nm == 0 at compile time, so this is just for better readability. For someone who just jumped into the code, size() is pretty self-explanatory but _Nm requires some digging.

Wouldn't it be a good idea, if you start another channel called "Rust Weekly" where you basically do go over the same topics as here but for Rust. I think this would be greatly beneficial for your audience.

Did not know you can tuple-ize that easy.

Thanks!

why the array data element is not private?

Would like to see more on Structure binding in C++ (8:47)

Good stuff, Thanks!

<cstddef> might be a more proper place to find std::size_t