Despite the multiple questions about performance\benefits\properties of std::array vs std::vector or C style array, I still never got a clear answer about actual practical usage and types of problems that can be (and should be solved with std::array). the reason i am asking is because me myself and in all the projects that i was working in C i never saw any usage of std::array but most of the work done with std::vector, is some are cases we used std:deque.

After compering the properties seems like array is something in the middle that like a C style array that have a thin(not so thin - have a lot of APIs) layer of abstraction but not heavy as std::vector. feel like if performance really matter or i have limitation because of embedded device i would still use C style array.

I tried to compare some other relatively large C project for example Notepad source code, and they very seldom use std::array only in json.hpp which is third party of its own, so to summarize

1. What are actual practical usage that can be solved by std::array better then other STL or native array?

2. is it possible that modern C compiler can optimize away all the abstraction leaving it basically like native C array.

3. I noticed in json.hpp that used by notepad source code that std::array used with char_traits and templates, is it possible that std::array can be used in implementation of other Libraries that are using templates and template meta-programming heavily while native C array would require more adapters or workaround that have performance penalty?

EDIT: I understand that std::array properties like fixed size and the sizes is known, but why it is still relatively seldom used.

Thanks a lot :)

CodePudding user response：

This question is somewhat broad and seems likely to go down the opinionated route, still:

ad.1 std::array provides STL-like API for C-style array. Moreover it prevents the array to pointer decay. The latter is oftentimes desired, e.g. due to the fact that size information is preserved when passing it.

ad.2 As for a general case - yes, std::array is a simple thin wrapper around its C-style counterpart. For specific cases - passing std::array by value can cause copies, which won't be the case for C-style array as the simply cannot be passed by value. On the other hand, this also provides a more consistent interface. Generally - if you are concerned about performance - measure. I dare say, in most cases it won't matter at all and if a form of static array is needed, std::array should be a go-to type over the C-style one, see C core guidelines on that topic.

Ad.3 Not sure I follow. Again: what std::array is, is mostly a convenience wrapper around C-style one. If you're interested in the gory details, you can look up boost::array, it should be pretty close to the std one. True, using C-style arrays would probably require more tinkering or just writing sth equivalent to the std::array class template. As for potentially less performant workarounds, the main one I can think of is vector or some other form of dynamically allocated storage.

Note, I wrote "potentially": contemporary compilers are allowed to elide heap operations, so again - measure first, judge later.

Also, the array vs vector dilemma often goes down to fixed-size vs. resizable , i.e. the intent of the programmer. Of course there is a plethora of exceptions to this rule, but for a most general case I'd opt for being expressive first.