current community

your communities

more stack exchange communities

Stack Exchange
tour help
stack overflow careers
Take the 2-minute tour ×
Stack Overflow is a question and answer site for professional and enthusiast programmers. It's 100% free, no registration required.
up vote 8 down vote favorite
3

This question already has an answer here:

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.

share|improve this question

marked as duplicate by Rapptz, Mark Garcia, Morwenn, 0x499602D2 24 mins ago

This question has been asked before and already has an answer. If those answers do not fully address your question, please ask a new question.
4  
You can implement your own make_array() function. –  0x499602D2 14 hours ago
1  
Thank you, that is helpful, I might use it. But when such a horribly complex (to me) function is required to do something C could do 30 years, it ago strikes me as wrong somehow. Furthermore I'm concerned my compiler won't be smart enough to compile it to exactly the same as putting the size in myself. –  Neil Kirk 14 hours ago

2 Answers 2

up vote 7 down vote

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 (with additional static_casts applied inside) because

array<double, 2> = { 42u, 3.14 };

is well-formed.

This paper intends to provide a set of std::array creation interfaces which are comprehensive from both tuple’s point of view and array’s point of view, so narrowing is just naturally banned. See more details driven by this direction in Design Decisions.

It also includes a sample implementation, which is rather long so copying here is impractical but Konrad Rudolph has a simplified version here which is consistent with the sample implementation above:

template <typename... T>
constexpr auto make_array(T&&... values) ->
    std::array<
       typename std::decay<
           typename std::common_type<T...>::type>::type,
       sizeof...(T)> {
    return std::array<
        typename std::decay<
            typename std::common_type<T...>::type>::type,
        sizeof...(T)>{std::forward<T>(values)...};
}
share|improve this answer
    
Yes but can you use that to store std::vector<std::array<type, different_sizes>>? Making a vector of std::array would require all the sizes to be the same? –  Brandon 14 hours ago
1  
@Brandon Unfortunately I think they would need to be the same size. Forget my suggestion in the other thread :( –  Neil Kirk 14 hours ago
    
@Brandon std::vector<std::array<type, different_sizes> > AFAIK is impossible. –  GingerPlusPlus 4 hours ago
    
Is there any reason return type deduction can't be used in that last sample or just return {std::forward<T>(values)...}? –  0x499602D2 22 mins ago
up vote 6 down vote

You're being a little overdramatic when you say "such a horribly complex (to me) function is required". You can make a simplified version yourself, the proposal also includes a "to_array" function to convert C-arrays and deducing the type from the first parameter. If you leave that out it gets quite manageable.

template<typename T, typename... N>
auto my_make_array(N&&... args) -> std::array<T,sizeof...(args)>
{
    return {std::forward<N>(args)...};
}

which you can then call like

auto arr = my_make_array<int>(1,2,3,4,5);

edit: I should mention that there actually is a version of that in the proposal that I overlooked, so this should be more correct than my version: 

template <typename V, typename... T>
constexpr auto array_of(T&&... t)
    -> std::array < V, sizeof...(T) >
{
    return {{ std::forward<T>(t)... }};
}
share|improve this answer
1  
Ok, that I can live with!! –  Neil Kirk 14 hours ago

Not the answer you're looking for? Browse other questions tagged or ask your own question.