Create N-element constexpr array in C++11

Unlike those answers in the comments to your question, you can do this without compiler extensions.

#include <iostream> template<int N, int... Rest> struct Array_impl { static constexpr auto& value = Array_impl<N - 1, N, Rest...>::value; }; template<int... Rest> struct Array_impl<0, Rest...> { static constexpr int value[] = { 0, Rest... }; }; template<int... Rest> constexpr int Array_impl<0, Rest...>::value[]; template<int N> struct Array { static_assert(N >= 0, "N must be at least 0"); static constexpr auto& value = Array_impl<N>::value; Array() = delete; Array(const Array&) = delete; Array(Array&&) = delete; }; int main() { std::cout << Array<4>::value[3]; // prints 3 } 

Based on @Xeo's excellent idea, here is an approach that lets you fill an array of

• constexpr std::array<T, N> a = { fun(0), fun(1), ..., fun(N-1) };
• where T is any literal type (not just int or other valid non-type template parameter types), but also double, or std::complex (from C++14 onward)
• where fun() is any constexpr function
• which is supported by std::make_integer_sequence from C++14 onward, but easily implemented today with both g++ and Clang (see Live Example at the end of the answer)
• I use @JonathanWakely 's implementation at GitHub (Boost License)

Here is the code

template<class Function, std::size_t... Indices> constexpr auto make_array_helper(Function f, std::index_sequence<Indices...>) -> std::array<typename std::result_of<Function(std::size_t)>::type, sizeof...(Indices)> { return {{ f(Indices)... }}; } template<int N, class Function> constexpr auto make_array(Function f) -> std::array<typename std::result_of<Function(std::size_t)>::type, N> { return make_array_helper(f, std::make_index_sequence<N>{}); } constexpr double fun(double x) { return x * x; } int main() { constexpr auto N = 10; constexpr auto a = make_array<N>(fun); std::copy(std::begin(a), std::end(a), std::ostream_iterator<double>(std::cout, ", ")); } 

Live Example

Use C++14 integral_sequence, or its invariant index_sequence

#include <iostream> template< int ... I > struct index_sequence{ using type = index_sequence; using value_type = int; static constexpr std::size_t size()noexcept{ return sizeof...(I); } }; // making index_sequence template< class I1, class I2> struct concat; template< int ...I, int ...J> struct concat< index_sequence<I...>, index_sequence<J...> > : index_sequence< I ... , ( J + sizeof...(I) )... > {}; template< int N > struct make_index_sequence_impl; template< int N > using make_index_sequence = typename make_index_sequence_impl<N>::type; template< > struct make_index_sequence_impl<0> : index_sequence<>{}; template< > struct make_index_sequence_impl<1> : index_sequence<0>{}; template< int N > struct make_index_sequence_impl : concat< make_index_sequence<N/2>, make_index_sequence<N - N/2> > {}; // now, we can build our structure. template < class IS > struct mystruct_base; template< int ... I > struct mystruct_base< index_sequence< I ... > > { static constexpr int array[]{I ... }; }; template< int ... I > constexpr int mystruct_base< index_sequence<I...> >::array[] ; template< int N > struct mystruct : mystruct_base< make_index_sequence<N > > {}; int main() { mystruct<20> ms; //print for(auto e : ms.array) { std::cout << e << ' '; } std::cout << std::endl; return 0; } output: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 

UPDATE: You may use std::array:

template< int ... I > static constexpr std::array< int, sizeof...(I) > build_array( index_sequence<I...> ) noexcept { return std::array<int, sizeof...(I) > { I... }; } int main() { std::array<int, 20> ma = build_array( make_index_sequence<20>{} ); for(auto e : ma) std::cout << e << ' '; std::cout << std::endl; } 

For std::array in C++17, constexpr function are also accepted Note that the var 'arr' must be initialized by constexpr required.
(initialize: same meaning with answer of @abyx)

#include <array> constexpr std::array<int, 3> get_array() { std::array<int, 3> arr{0}; arr[0] = 9; return arr; } static_assert(get_array().size() == 3); 

With C++17 this can be done easily as std::array::begin is marked constexpr.

template<std::size_t N> std::array<int, N + 1> constexpr make_array() { std::array<int, N + 1> tempArray{}; int count = 0; for(int &elem:tempArray) { elem = count++; } return tempArray; } int main() { //-------------------------------vv------>pass the size here constexpr auto arr = make_array<5>(); //lets confirm if all objects have the expected value for(const auto &elem: arr) { std::cout << elem << std::endl; //prints 1 2 3 4 5 with newline in between } } 

Demo

#include <array> #include <iostream> template<int... N> struct expand; template<int... N> struct expand<0, N...> { constexpr static std::array<int, sizeof...(N) + 1> values = {{ 0, N... }}; }; template<int L, int... N> struct expand<L, N...> : expand<L-1, L, N...> {}; template<int... N> constexpr std::array<int, sizeof...(N) + 1> expand<0, N...>::values; int main() { std::cout << expand<100>::values[9]; } 

Using boost preprocessor, it's very simple:

 #include <cstdio> #include <cstddef> #include <boost/preprocessor/repeat.hpp> #include <boost/preprocessor/comma_if.hpp> #define IDENTITY(z,n,dummy) BOOST_PP_COMMA_IF(n) n #define INITIALIZER_n(n) { BOOST_PP_REPEAT(n,IDENTITY,~) } int main(int argc, char* argv[]) { int array[] = INITIALIZER_n(25); for(std::size_t i = 0; i < sizeof(array)/sizeof(array[0]); ++i) printf("%d ",array[i]); return 0; } 

OUTPUT:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24