stdarray

This question already has an answer here: Is the size of std::array defined by standard 1 answer What does the C++ standard say about what sizeof(std::array<char, N>) should be (for some constant N )? In a comment to a different question , it was mentioned that std::array is not always "stack allocated". The comment was in response to a different comment that speculated that putting a too large of a constant for std::array that is declared as a local variable could cause the program to abort due to insufficient resources for the "stack allocated" variable. I assume the followup comment meant

I'm making a little class that uses an array templated on its size. Here's some code... .hpp template <size_t N> class KeyCombinationListener { public: KeyCombinationListener( const std::array<sf::Keyboard::Key, N>& sequence, std::function<void (void)> fn ); private: std::array<sf::Keyboard::Key, N> combo; std::function<void (void)> callback; }; .cc template <size_t N> KeyCombinationListener<N>::KeyCombinationListener( const array<sf::Keyboard::Key, N>& sequence, function<void (void)> fn ) : combo(sequence), progress{begin(combo)}, callback{fn} { } In the member initialization of the

Here are 8 ways to declare and initialize arrays in C++11 that seems ok under g++ : /*0*/ std::array<int, 3> arr0({1, 2, 3}); /*1*/ std::array<int, 3> arr1({{1, 2, 3}}); /*2*/ std::array<int, 3> arr2{1, 2, 3}; /*3*/ std::array<int, 3> arr3{{1, 2, 3}}; /*4*/ std::array<int, 3> arr4 = {1, 2, 3}; /*5*/ std::array<int, 3> arr5 = {{1, 2, 3}}; /*6*/ std::array<int, 3> arr6 = std::array<int, 3>({1, 2, 3}); /*7*/ std::array<int, 3> arr7 = std::array<int, 3>({{1, 2, 3}}); What are the correct ones according to the strict standard (and the upcoming C++14 standard) ? What are the most common/used and

On g++ 4.9.2 and 5.3.1, this code takes several seconds to compile and produces a 52,776 byte executable: #include <array> #include <iostream> int main() { constexpr std::size_t size = 4096; struct S { float f; S() : f(0.0f) {} }; std::array<S, size> a = {}; // <-- note aggregate initialization for (auto& e : a) std::cerr << e.f; return 0; } Increasing size seems to increase compilation time and executable size linearly. I cannot reproduce this behaviour with either clang 3.5 or Visual C++ 2015. Using -Os makes no difference. $ time g++ -O2 -std=c++11 test.cpp real 0m4.178s user 0m4.060s sys

This question already has an answer here: How to emulate C array initialization “int arr[] = { e1, e2, e3, … }” behaviour with std::array? 9 answers How can I make a3 compile? int main() { int a1[] = { 1, 2, 3 }; std::array<int, 3> a2 = { 1, 2, 3 }; std::array<int> a3 = { 1, 2, 3 }; } It's very inconvenient, and brittle, to hard-code the size of the array when using an initialization list, especially long ones. Is there any work around? I hope so otherwise I'm disappointed because I hate C arrays and std::array is supposed to be their replacement. There is currently no way to do this without