Subject: Re: [boost] [preprocessor] Warning: Incoming
From: Paul Mensonides (pmenso57_at_[hidden])
Date: 2011-07-01 19:55:59
On Sat, 02 Jul 2011 01:07:04 +0200, Mathias Gaunard wrote:
> On 07/02/2011 12:44 AM, Paul Mensonides wrote:
>> (I
>> do believe, however, that std::initializer_list<T> is a misfeature. I
>> personally think the { a, b, c } should have been mapped onto a
>> constructor call taking a, b, and c--which may or may not use variadic
>> templates).
>
> Both are possible in C++0x.
> That's how you initialize tuples.
The { a, b, c } syntax does not map onto constructors. It maps onto
std::initializer_list<T> for some particular (and unique) T. With C++0x,
T x { U(), U(), U() }; // or whatever the exact syntax is
maps onto a constructor T(std::initializer_list<U>). (I haven't played
around with the details enough to remember off hand the exact semantics,
so bear that in mind.) However,
T x { U(), V(), W() };
typically maps onto epic fail.
IMHO, std::initializer_list<T> should not exist as a language level
type. Variadic templates are enough provided the language maps the above
syntax directly to a constructor invocation. E.g.
T x { a, b, c }
mapping to T(a, b, c).
With that, you could have done everything that std::initializer_list<T>
could do and much more. (E.g. initialize a tuple containing values of
differing types.) You could even have added tools at the library level
to make it easier to write the constructors for non-expert users.
Given that, C's designated initializers (et al) could have been added to C
++ as a special case of keyword arguments which, in turn, could have been
extended to regular functions, not just constructors.
Regards,
Paul Mensonides