Is the size of std::array defined by standard

by

It’s nearly required. Specifically, §23.3.2.1/2 says:

An array is an aggregate (8.5.1) that can be initialized with the syntax

array<T, N> a = { initializer-list };

where initializer-list is a comma-separated list of up to N elements whose types are convertible to T.

Since it’s an aggregate, it can’t use any sort of constructor to convert the data in the initializer-list to the correct format. That really only leaves one possibility: about the only thing it can store are the values themselves.

I suppose it would be possible for an std::array to store some sort of auxiliary data following the specified data, such as extra memory set to some predefined value, so if you write past the end of the array, you’d probably change that data. The compiler/run-time would then check those values at shut-down, and if you’d changed the values, report your code’s undefined behavior.

It’s also possible that a compiler could do padding/alignment differently for an std::array than for a built-in array. One obvious example for which this could even be desirable would be to support super-alignment requirements, such as data for use with Intel’s SSE instructions. A built-in array can’t support super-alignment, but I think the specification of std::array might be barely loose enough to allow it.

Bottom line: without getting into questions of how many possibilities might exist, it’s pretty clear that std::array doesn’t necessarily have to follow the rule you’re asking about.

More Related Contents:

  1. C++11 introduced a standardized memory model. What does it mean? And how is it going to affect C++ programming?
  2. Will std::string always be null-terminated in C++11?
  3. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  4. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  5. When is a private constructor not a private constructor?
  6. Why is template argument deduction disabled with std::forward?
  7. Why use non-member begin and end functions in C++11?
  8. Matching alias template as template argument
  9. std::vector, default construction, C++11 and breaking changes
  10. Do I really need to implement user-provided constructor for const objects?
  11. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  12. Is std::abs(0u) ill-formed?
  13. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  14. So why is i = ++i + 1 well-defined in C++11?
  15. C++11 STL containers and thread safety
  16. How can I use Standard Library (STL) classes in my dll interface or ABI?
  17. When do extra parentheses have an effect, other than on operator precedence?
  18. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  19. Is a constexpr array necessarily odr-used when subscripted?
  20. Legal to overwrite std::string’s null terminator?
  21. Comparing 3 modern c++ ways to convert integral values to strings
  22. Why isn’t std::array::size static?
  23. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  24. Calling an explicit constructor with a braced-init list: ambiguous or not?
  25. Can we apply content not explicitly cited from the normative references to the C++ standard?
  26. Calling delete on NULL pointers – C++03 vs C++11
  27. std::tuple memory alignment
  28. Rvalues, lvalues and formal definitions
  29. What is use of the ref-qualifier `const &&`?
  30. C++11 std::to_string(double) – No trailing zeros

Leave a Comment