You can use a type alias template: #include <array> #include <cstddef> template <class T, std::size_t x, std::size_t y> using Array2D = std::array<std::array<T, y>, x>; int main() { Array2D<int, 5, 3> arr; } You can also generalize it like so for any dimension: #include <array> #include <cstddef> template <class T, std::size_t size, std::size_t… sizes> struct ArrayHelper … Read more
What are the advantages of using std::array over usual ones? It has friendly value semantics, so that it can be passed to or returned from functions by value. Its interface makes it more convenient to find the size, and use with STL-style iterator-based algorithms. Is it more performant ? It should be exactly the same. … Read more
I wouldn’t worry about it. If you look at the interface of std::array<T, N>, it is very small and most member functions (basically providing wrappers for pointer manipulation) are one-liners that will be completely optimized away / inlined by any decent compiler on Release mode optimization levels. Furthermore, you don’t pay for what you don’t … Read more
Add another pair of braces. std::array<std::pair<int, int>, 2> ids = { { { 0, 1 }, { 1, 2 } } }; std::array<T, N> is an aggregate class containing a member of type T[N]. Usually, you can initialise that the same way you would a plain T[N] array, but when you’re dealing with a non-aggregate … Read more
For completeness’ sake, here’s a version that does not require the definition of a function but instead uses a lambda. C++17 introduced the ability of using lambdas in constant expressions, so you can declare your array constexpr and use a lambda to initialize it: static constexpr auto axis = [] { std::array<double, num_points> a{}; for … Read more
With std::index_sequence, you might do: namespace detail { template <typename T, std::size_t … Is> constexpr std::array<T, sizeof…(Is)> create_array(T value, std::index_sequence<Is…>) { // cast Is to void to remove the warning: unused value return {{(static_cast<void>(Is), value)…}}; } } template <std::size_t N, typename T> constexpr std::array<T, N> create_array(const T& value) { return detail::create_array(value, std::make_index_sequence<N>()); } With usage … Read more
If you have a generic function it is bad if that function randomly breaks for special parameters. For example, lets say you could have a template function that takes N random elements form a vector: template<typename T, size_t N> std::array<T, N> choose(const std::vector<T> &v) { … } Nothing is gained if this causes undefined behavior … Read more
Arrays do not have any indirection, but just store their data “directly”. That is, a std::array<int, 5> literally contains five ints in a row, flat. And, like vectors, they do not put padding between their elements, so they’re “internally contiguous”. However, the std::array object itself may be larger than the set of its elements! It … Read more
You may use std::tuple_size: std::tuple_size<decltype(Foo::bar)>::value
There is currently no way to do this without rolling your own make_array, there is a proposal for this N3824: make_array which has the following scope: LWG 851 intended to provide a replacement syntax to array<T, N> a = { E1, E2, … }; , so the following auto a = make_array(42u, 3.14); is well-formed … Read more