关于std::vector<std::array<double, dim>>与std::vector<double>底层存储等价性及指针使用安全性的疑问

Yes, you can safely use the pointer from vad.data()->data() as if it were returned by an equivalent std::vector<double>::data(), and this is guaranteed by the C++ standard with no aliasing issues or undefined behavior (UB) — provided you don’t access memory beyond the valid range of doubles.

Here’s a breakdown of why this works:

Contiguous Storage Guarantees #

The key points from the C++ standard that ensure your approach is valid are:

• std::vector stores elements contiguously: For any non-bool std::vector<T>, the standard mandates that &v[n] == &v[0] + n for all valid indices n. This means the std::array objects in your vad vector are laid out back-to-back in memory with no gaps between them.
• std::array has no internal padding: The size of std::array<double, dim> is exactly dim * sizeof(double) (per [array]/4 in the C++ standard). There are no hidden bytes or padding between the double elements inside a std::array, and the std::array itself has no extra overhead.
• Combined effect: The entire std::vector<std::array<double, dim>> occupies a single contiguous block of memory containing exactly (size/dim) * dim = size double values. The pointer vad.data()->data() points to the first double in this block, so you can treat it identically to a pointer from std::vector<double>::data().

No Aliasing Violations #

The strict aliasing rule (which restricts how you can access objects through different pointer types) does not apply here. You’re accessing double objects using a double* pointer, which is explicitly allowed by the rule. There’s no type mismatch or invalid aliasing happening in your code.

Important Caveats #

While your approach is safe, keep these points in mind:

• Don’t exceed valid memory: Ensure you never read or write more than the total number of doubles in the vector (i.e., size in your example). Accessing beyond this range is undefined behavior.
• This only applies to std::array: This logic works because std::array is a lightweight, padding-free wrapper for fixed-size arrays. If you used a vector of a custom struct (with potential padding between elements or non-contiguous internal data), this guarantee would not hold.

In your code example, when you use scan_vad to iterate through the doubles, you’re correctly accessing the contiguous block of memory. The output confirms that the values are laid out exactly as they would be in a std::vector<double>.

内容来源于stack exchange