Understanding the Challenge of std::span Construction from std::array of std::shared_ptr void

Learn about the challenges and reasons why you can't construct a `std::span std::shared_ptr T ` from `std::array std::shared_ptr void , N ` in C+ + .
---
This video is based on the question https://stackoverflow.com/q/62740130/ asked by the user 'Voidev' ( https://stackoverflow.com/u/4986319/ ) and on the answer https://stackoverflow.com/a/62741899/ provided by the user 'Davis Herring' ( https://stackoverflow.com/u/8586227/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Construct a span shared_ptr T from an array shared_ptr void

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding the Challenge of std::span Construction from std::array of std::shared_ptr<void>

In C+ + , working with smart pointers and memory management is crucial for maintaining safe and efficient code. One common situation developers encounter is the need to convert a collection of shared pointers of one type to another. Specifically, let's consider the question posed:

Can we construct a std::span<std::shared_ptr<T>> from an std::array<std::shared_ptr<void>, N>?

The Problem Explained

When dealing with collections in C+ + , such as arrays or spans, type conversions are often necessary. In this scenario, you have an std::array containing shared pointers of type void, and you want to access the data as a different type using std::span. A span provides a way to refer to a contiguous sequence of objects without owning the underlying storage, making it a convenient way to handle subarrays.

However, attempting to convert a std::array<std::shared_ptr<void>, N> directly into std::span<std::shared_ptr<T>> leads to undefined behavior (UB). Let's understand why this occurs.

Why The Conversion is Impossible

The fundamental problem lies in the way that pointers and shared pointers are structured internally in C+ + . Here's a breakdown of the reasons:

1. Pointer Type Incompatibility

void pointers are generic, but they don't carry type information. You cannot assert that a std::shared_ptr<void> can be safely treated as a std::shared_ptr<T>.

The conversion from void* to T* is permissible under certain conditions, but that's not the whole picture.

2. Incompatible Pointer Types Exception

You cannot convert a void** (pointer pointing to a void*) to a T** (pointer for T*). This is due to the absence of actual objects of type T being stored in such a structure.

Furthermore, you can't convert std::shared_ptr<A>* to std::shared_ptr<B>* when A and B are different types. The internal structure of std::shared_ptr<T> includes a control block that supports reference counting and deferred deallocation, which complicates direct conversions.

3. Array and Structure Unwrapping Restrictions

C+ + does not allow you to "unwrap" arrays of structures like shared pointers and treat them as arrays of their contents due to strict typing rules. The only exception being std::complex, which is heavily controlled.

Conclusion

In conclusion, attempting to construct a std::span<std::shared_ptr<T>> from std::array<std::shared_ptr<void>, N> is impossible without invoking undefined behavior. The intricacies of pointer types, the role of control blocks in shared pointers, and strict type safety in C+ + all contribute to this limitation.

For developers navigating similar challenges, it’s essential to be mindful of type conversions and memory management nuances in C+ + . Understanding these rules will save you from subtle bugs and ensure that your code remains safe and reliable.

By keeping these principles in mind, you'll enhance your proficiency in C+ + and manage shared resources with confidence.