Is the absence of
std::array<T,size>::array(const T& value);
an oversight? It seems mighty useful to me, and dynamic containers (like std::vector) do have a similar constructor.
I am fully aware of
std::array<T,size>::fill(const T& value);
but that is not a constructor, and the memory will be zeroed out first. What if I want all -1's like this guy?
std::array is, by design, an aggregate, so has no user-declared constructors.
As you say, you could use fill after default constructing. Since it's an aggregate, default construction won't zero the memory, but will leave it uninitialised (if the contained type is trivially initialisable).
:/
Note that you can efficiently simulate this type of constructor by taking advantage of the fact that array is not zero-initialized, and has a copy constructor and do.
template <size_t N, class T>
array<T,N> make_array(const T &v) {
array<T,N> ret;
ret.fill(v);
return ret;
}
auto a = make_array<20>('z');
;-).
char can be inferred, so you can just write make_array<20>('z') instead of make_array<20,char>('z')make_array instead :-)
T is not default constructible, and that's when you need the fill constructor badly.You may use std::index sequence for that:
namespace detail
{
template <typename T, std::size_t...Is>
constexpr std::array<T, sizeof...(Is)>
make_array(const T& value, std::index_sequence<Is...>)
{
return {{(static_cast<void>(Is), value)...}};
}
}
template <std::size_t N, typename T>
constexpr std::array<T, N> make_array(const T& value)
{
return detail::make_array(value, std::make_index_sequence<N>());
}
std::make_index_sequence is C++14, but can be implemented in C++11.
static_cast<void>(Is) is to handle evil operator, that T might provide.
T is not default constructible, which is when the other answers fall short.
std::index_sequence might be implemented with logarithm instantiation instead of linear. and compiler might have "intrinsics" to do only one instantiation. Then, there are no longer recursion.std::vector, and reserve whole size and emplace_back in a loop.As for a million-element, stack would be problematic as memory limited in practice.First of all, it is not std::array<T>, it is std::array<T,N> where N is compile time constant integral expression.
Second, std::array is made aggregate by design. So it doesn't have anything which makes it non-aggregate, which is why it doesn't have constructor... and destructor, virtual functions, etc.
I took answer from Jarod42 and made an extension to be able to use variable amount of Constructor arguments and also added automatic indexer as a first arg:
namespace detail {
template <typename T, std::size_t... Seq, typename... Args>
constexpr std::array<T, sizeof...(Seq)> make_array(std::index_sequence<Seq...>, Args &... args)
{
return {{(static_cast<void>(Seq), T(Seq, args...))...}};
}
} // namespace detail
template <typename T, std::size_t N, typename... Args>
constexpr std::array<T, N> make_array(Args &... args)
{
return detail::make_array<T>(std::make_index_sequence<N>(), args...);
}
class myClass {
myClass(unsigned int i, float a, std::string b, int c):... {};
}
Usage:
auto myArray = make_array<myClass, 64>(a, b, c);
std::vector). So since it would always be equivalent toarray(); array.fill();, omitting the constructor in the first place doesn't hide this fact.std::array<int, 10> a = { [0 ... 9] = 1}.