Is Aliasing a Plain Array to an `std::array` Not UB?

Welcome, fellow C++ enthusiasts! In this article, we’ll embark on a thrilling adventure to explore the fascinating realm of aliasing, std::array, and the often-misunderstood concept of Undefined Behavior (UB). So, buckle up and get ready to dive into the depths of C++!

What’s the Question Again?

The burning question that sparked this investigation is: “Is aliasing a plain array to an `std::array` not UB?” To answer this, we need to break down the individual components and understand how they interact with each other.

What is Aliasing?

In the context of C++, aliasing refers to the process of assigning a new name to an existing object or entity. This can be achieved using various techniques, such as:

• References: Creating a reference to an object, which acts as an alternative name for the original object.
• Pointers: Assigning the address of an object to a pointer, which can then be used to access the object.
• Type aliasing: Using a type alias, such as a typedef or a using statement, to create a new name for an existing type.

In our specific case, we’re interested in aliasing a plain array to an `std::array`.

What is `std::array`?

`std::array` is a fixed-size, sequence container that stores elements of type T in contiguous storage. It’s a part of the C++ Standard Library and provides a convenient way to work with arrays without the hassle of manual memory management.

template<class T, std::size_t N>
struct array {
    // ...
};

Now that we’ve covered the basics, let’s delve into the meat of the matter.

The Investigation

To determine whether aliasing a plain array to an `std::array` is UB, we need to explore the C++ Standard and the properties of `std::array`.

The C++ Standard

According to the C++ Standard, specifically [class.array]p3:

"An object of type std::array<T, N> is an aggregate that contains N elements of type T."

This implies that `std::array` is an aggregate type, which has specific implications for initialization and assignment.

`std::array` and Aggregate Initialization

When initializing an `std::array`, the elements are aggregated using the corresponding constructor for the element type. This means that the elements are constructed in-place, using the provided initializer.

std::array<int, 3> arr = {{1, 2, 3}};

In this example, the `std::array` is initialized using an aggregate initializer, which constructs the elements in-place.

Aliasing a Plain Array to an `std::array`

Now, let’s consider the scenario where we alias a plain array to an `std::array`:

int plainArray[3] = {1, 2, 3};
std::array<int, 3> aliasArray = plainArray;

At first glance, this might seem like a reasonable approach. However, let’s examine what’s happening behind the scenes.

What’s Really Happening?

When we alias a plain array to an `std::array`, the `std::array` constructor is not actually constructing the elements in-place. Instead, it’s using the copy constructor to copy the elements from the plain array to the `std::array`.

std::array<int, 3> aliasArray = plainArray;
// equivalent to:
std::array<int, 3> aliasArray = std::array<int, 3>(plainArray);

This is where things get interesting. The `std::array` constructor is using the copy constructor to copy the elements, which implies that the elements are being copied using the `T(T const&)` constructor.

The Crux of the Matter

The key insight here is that the `std::array` constructor is not using aggregate initialization to construct the elements. Instead, it’s relying on the copy constructor to copy the elements from the plain array.

This means that the elements of the `std::array` are not constructed in-place using the provided initializer. Instead, they’re being copied from the plain array, which can lead to unexpected behavior if the underlying type has specific requirements for initialization.

Is it UB?

So, is aliasing a plain array to an `std::array` UB? The answer is not necessarily. However, it can lead to unexpected behavior or UB depending on the specific circumstances.

When it’s Not UB

If the underlying type is a trivial type, such as an `int` or a `char`, the copy constructor will work as expected, and the aliasing will not result in UB.

int plainArray[3] = {1, 2, 3};
std::array<int, 3> aliasArray = plainArray; // OK

When it Might be UB

However, if the underlying type has specific requirements for initialization, such as a constructor that performs side effects, the copy constructor might not work as expected. This can lead to UB or unexpected behavior.

struct NonTrivial {
    NonTrivial() { /* performs side effects */ }
};

NonTrivial plainArray[3] = {{}, {}, {}};
std::array<NonTrivial, 3> aliasArray = plainArray; // potential UB

In this scenario, the copy constructor of `std::array` will use the copy constructor of `NonTrivial`, which might not correctly initialize the elements. This can lead to UB or unexpected behavior.

Conclusion

In conclusion, aliasing a plain array to an `std::array` is not necessarily UB, but it can lead to unexpected behavior or UB depending on the specific circumstances. It’s essential to understand the underlying type’s requirements for initialization and the implications of using the copy constructor.

When working with `std::array`, it’s crucial to use aggregate initialization to ensure that the elements are constructed correctly. If you need to alias a plain array, consider using a different approach, such as:

std::array<int, 3> aliasArray;
std::copy(std::begin(plainArray), std::end(plainArray), aliasArray.begin());

By being mindful of the complexities involved, you can ensure that your code is both correct and efficient.

Thanks for joining me on this fascinating journey into the world of aliasing, `std::array`, and Undefined Behavior! If you have any questions or comments, feel free to share them below.

Keyword	Summary
Aliasing	Assigning a new name to an existing object or entity
`std::array`	A fixed-size, sequence container that stores elements of type T in contiguous storage
Aggregate Initialization	A process of initializing an aggregate type, such as an array or struct, using an initializer
Undefined Behavior (UB)	Behavior that is not defined by the C++ Standard, which can lead to unexpected results or errors

---

This article has been optimized for the keyword “is aliasing a plain array to an `std::array` not UB” and is intended to provide a comprehensive explanation of the topic. If you have any questions or need further clarification, please don’t hesitate to ask!

Frequently Asked Question

Get the lowdown on whether aliasing a plain array to an `std::array` is a recipe for disaster or a clever trick!