Pfthb

You can work around the need for all the types in the list to be the same by using an explicit deduction guide:

template <class... T>
Array(T&&... t) -> Array<std::common_type_t<T...>, sizeof...(T)>;

Array foo = 1.0, 2.0, 3.0f ; // Deduces Array<double,3u>

I hate to be the bearer of bad news, but I believe that at the current time (at least as of C++17) the answer to your question is "no" there is no way that would meet all of your given requirements. That said, there are solutions posted here that come close, but they all fall short in one or more of your requirements.

I also suspect that the answer will remain "no" in the near future. Not that I'm a prophet, but the direction of the last few C++ versions would seem to imply that a make_array solution is more likely to be what is added rather than more direct language support.

Explanation

Allow me to explain why in a little more detail.

First consider the C++17 deduction guides. I won't go into detail on them as they are discussed suitably by other answers on this question. They do come very close to what you are asking but do seem to fall short in one way or the other. (Although the answer by @max66 would seem to meet all your requirements except for the extra brackets. If his syntax in fact works you may want to consider that answer as "close enough".)

Next consider a variatic templates solution. In order to automatically determine N you would need a series of overloaded functions (basically one with a single argument and one that takes a single argument and the rest of the variatic templates). But that would essentially be equivalent to some form of make_array so it doesn't count either.

Finally, the only other option I could see would be based on an initializer_list. The question is how to determine N from that list. In C++11 this would be obviously impossible since the only access to the size of the list is const and not constexpr. However as of C++14 the size() method is in fact constexpr so you would think it is at least theoretically possible to get the compiler to deduce N based on that. Unfortunately to do this you would need to make N (a template parameter) default to a value of something in the class constructor (the initializer list). I have been unable to determine any means of doing this in the present form of the language.

How I think a future version could support this

One way to support this would be to follow the examples of other languages and add direct language support, bridging a syntax to certain classes. But this essentially makes some classes "special". Consider the following line in Swift:

let ar = [1, 2, 3, 4]

In this example ar is an object of the type Array<Int>. But this is done by direct compiler support, i.e. "Array" is a special case. No matter what you do you could not write a MyArray class that would perform the same way (other than perhaps having MyArray accept an Array as a construction option). It is certainly possible for the C++ standard to be extended to do something similar, but C++ tends to try to avoid those "special" cases. Besides, an argument could be made that

auto ar = make_array(1, 2, 3, 4);

is in fact a clearer representation of the intent than would be something like the following: (suggesting the character 'A' to distinguish this from an initializer list)

auto ar = A 1, 2, 3, 4 ;

Another way, more in line with current C++ syntax, to do this would be to add the N parameter to the initializer_list template class. After all since size() is now constexpr the size must be known at compile time, so why not make it available as a template parameter? It could suitably default so that it could rarely be needed, but it would allow classes (both standard ones like std::array and custom ones like you are proposing) the possibility of tying the N in the Array template to the N in the initializer_list. Then you should be able to write something along the following lines:

template<class T, size_t N>
struct Array 

 explicit Array(std::initializer_list<N> il);

Of course the trick would be to make this initializer_list change in a fashion that does not break a lot of existing code.

I suspect the standards committee will not follow either of these paths, but will more likely add the experimental make_array method. And I'm not convinced that is a bad idea. We are used to make_... in many other parts of the language, so why not here as well?

Here's one approach that allows you to specify the type. We use an extra argument to specify the type, so that we can still use the deduction guide to pick up the size. I don't consider it pretty though:

#include <iostream>

template <typename T>
struct Tag ;

template <typename T, size_t N>
struct Array 
 T data_[N];

 template <typename... U>
 Array(Tag<T>, U... u)
 : data_static_cast<T>(u)... // cast to shut up narrowing conversions - bad idea??
 
;

template <typename T, typename... U>
Array(Tag<T>, U...) -> Array<T, sizeof...(U)>;

int main()

 Array aTag<double>, 1, 2.0f, 3.0;
 for (auto d : a.data_) 
 std::cout << d << 'n';
 

This is clearly not a full implementation of such a class, just to illustrate the technique.

Deduction guides in C++17 nearly work, but you have to omit the type parameter and all items must have exactly the same type

Not necessarily.

Yes, you can't explicit the type parameter, but you can decide it according the types of the items.

I imagine two reasonable strategies: (1) the type of the Array is the type of the first item, following the std::array way, so writing the following deduction guide

template <typename T, typename ... Us>
Array(T, Us...) -> Array<T, 1u + sizeof...(Us)>; 

(but observe that a C++ program where a Us type is different from T, for a std::array, is ill formed) or (2) follows the metalfox's suggestion and select the item's common type

template <typename ... Ts>
Array(Ts...) -> Array<std::common_type_t<Ts...>, sizeof...(Ts)>;

Is the braced-init-list to T[N] that happens in int foo = 1, 2, 3 ; purely compiler magic that can't be replicated in code?

Are you thinking in a deduction guide as follows ?

template <typename T, std::size_t N>
Array(T const (&)[N]) -> Array<T, N>;

Works but with a couple of drawbacks: (1) you have to add a couple of brackets using it

// added ---V V--- added
Array foo1 = 1, 2, 3 ; // Works

and (2) remain the problem that all items must have the same type

Array foo2 = 1.0, 2.0, 3.0f ; //Doesn't work: incompatible types

or the compiler can't deduce the type T

P.s.: what's wrong with a make_array() function ?

P.s.2: I suggest to give a look at BoBTFish's answer to see a nice method to bypass the impossibility to explicit a template argument using deduction guides.

You had asked this:

Q: Is there anyway to create an Array class that can be initialized with a braced-init-list without having to manually specify the array length, and without a 'make_array' function.

I have worked on an implementation of a class that behaves in the manner you are describing only it has a little bit more complexity to it but still fairly simple, readable, reusable, portable and generic.

I was not able to have a T items array as a direct member in the class. I had to use a T* items instead and create an overloaded operator in the derived class to mimic the behavior of an array. This doesn't mean that there isn't any work around to this as others have shown. I just find that this is one possible solution without having to specify the size of the array.

I use a base class to store the elements from the constructor either by means of an std::initializer_list or of a variadic constructor. The class templates themselves are not a variadic template only their constructor's are. The base class stores the values from the initializer_list or parameter pack into an std::vector. The inherited class stores the contents from the vector into T* by calling the data() function of the vector class.

template<typename T>
class ParamPack 
protected:
 std::vector<T> values_;
 size_t size_;
public:
 template<typename... U>
 ParamPack( U... u ) : 
 values_ static_cast<T>(u)... , 
 size_( sizeof...(U) ) 

 template<typename ... U>
 ParamPack( std::initializer_list<std::is_same<T, U...>( U...)> il ) : 
 values_( il ), size_( il.size() ) 

 std::vector<T>& operator()() return values_; 

 size_t size() const return size_; 
; 

template<typename T>
class Array : public ParamPack<T> 
private:
 T* items_;
public:
 template<typename... U>
 Array( U... u ) : ParamPack<T>::ParamPack( u... ) 
 items_ = this->values_.data();
 

 template<typename... U>
 Array( std::initializer_list<U...> il ) : ParamPack<T>::ParamPack( il ) 
 items_ = this->values_.data();
 

 T& operator( size_t idx ) 
 return items_[idx];
 

 T operator( size_t idx ) const 
 return items_[idx];
 

 T* data() const return items_; 
;

int main() 
 try 
 // Parameter Pack Examples:
 // Variadic Constructor ... 
 std::cout << "ParamPack<T> Examples:n";
 std::cout << "Using ParamPack<T>'s Variadic Constructorn";
 ParamPack<int> pp1( 1, 2, 3, 4 );
 std::cout << "Size: " << pp1.size() << " catch( const std::runtime_error& e ) 
 std::cerr << e.what() << 'n';
 return EXIT_FAILURE;
 

 return EXIT_SUCCESS;

-Output-

ParamPack<T> Examples:
Using ParamPack<T>'s Variadic Constructor
Size: 4 | Elements: 1 2 3 4
Using ParamPack<T>'s Variadic Constructor with an Initializer List
Size: 4 | Elements: 5 6 7 8 
Using ParamPack<T>'s initializer_list Constructor
Size: 4 | Elements: 9 10 11 12

Array<T> Examples:
Using Array<T>'s initializer_list Constructor
9 10 12 12

Using Array<T>'s Variadic Constructor
9 8 7 6
Hello World

Using Array<T>'s Constructor with Initializer List
105 210 420

Using Array<T>'s Initializer List with =
1 2 3 4
a b c d
1.2 3.4 5.6 7.8

Using Array<T>'s Initializer List directly
3 6 9 12

Using Array<T>'s Variadic Constructor with user data type
(1,2) (3,4) (5,6)
Using Array<T>'s Variadic Constructor With Initializer List of user data type
(5,6) (3,4) (1,2)
Using Array<T>'s = Initializer List with user data type
(3,4) (1,2) (5,6)
Using Array<T>'s Initializer List directly with user data type
(3,4) (5,6) (1,2)
Using Array<T>'s initializer_list Constructor with user data type

Using Array<T>'s base class's operator()() to retrieve vector
(3,4) (5,6) (1,2) 
Using Array<T>'s data() to get the contents of its internal pointer
(3,4) (5,6) (1,2)

Now this is a little more robust as it has operators that are available from both the parent and child class, from the parent class you can get the stored vector directly from its operator()(). From the child class you can index into the child's stored pointer from operator() and there is a function to return it's size. The template itself does not contain a size_t N template argument since the size is stored internally in the base class and is determined by the size of its vector. With this I'm treating T* p as if it was T p[size]. This class is still not without some limitations.

-Valid Construction-

Array<int> a( 1, 2, 3, 4 ); // Variadic Constructor Okay
Array<int> a( 1,2,3,4 ); // Initializer List Constructor Okay
Array<int> a = 1, 2, 3, 4 ; // Initializer List Okay
Array<int> a 1,2,3,4 ; // Initializer List Okay 

-Limitations-

However you have to explicitly instantiate the template as these will not work as they all generate a compiler error.

Array a( 1,2,3,4 );
Array a( 1,2,3,4 );
Array a = 1, 2, 3, 4 ; 
Array a 1,2,3,4 ;

-Note- There maybe more that can be done to make this more efficient, maybe even thread safe or exception safe, but this is just a generalization of the class design.

Please let me know what you think about this: