A “thing” like {1,2,3} does not qualify as an expression. It has no type. Therefore, no type deduction is done. But C++0x makes an explicit exception for ‘auto’, so auto x = {1,2,3}; actually works and decltype(x) will be initializer_list<int>. But this is a special rule that only applies to auto. I guess they wanted … Read more
Yes, this behaviour is intended, according to §13.3.1.7 Initialization by list-initialization When objects of non-aggregate class type T are list-initialized (8.5.4), overload resolution selects the constructor in two phases: — Initially, the candidate functions are the initializer-list constructors (8.5.4) of the class T and the argument list consists of the initializer list as a single … Read more
Yes, the code is valid and does not have undefined behavior. Expressions in an initizalizer list are evaluated left-to-right and sequenced before the evaluation of the constructor of S. Therefore, your program should consistently assign value 2 to variable i. Quoting § 8.5.4 of the C++ Standard: “Within the initializer-list of a braced-init-list, the initializer-clauses, … Read more
Answering my own question. Deleting the question would not be a good idea, as someone might have the same question in the future. Yes. It is a bug in the GCC compiler. Bug 51253 – [C++11][DR 1030] Evaluation order (sequenced-before relation) among initializer-clauses in braced-init-list taken from @Johannes Schaub’s comment to the question.
It can only be done for aggregates (arrays and certain classes. Contrary to popular belief, this works for many nonpods too). Writing a constructor that takes them is not possible. Since you tagged it as “C++0x”, then this is possible though. The magic words is “initializer-list constructor”. This goes like Phenotype(std::initializer_list<uint8> c) { assert(c.size() <= … Read more
You can use a variadic template constructor instead of an initializer list constructor: struct foo { int x[2]; template <typename… T> foo(T… ts) : x{ts…} { // note the use of brace-init-list } }; int main() { foo f1(1,2); // OK foo f2{1,2}; // Also OK foo f3(42); // OK; x[1] zero-initialized foo f4(1,2,3); // … Read more
To make long story short: a braced initializer expression {} has no type by itself auto has to infer type information int{3} obviously means “create an int var with value taken from initializer list”, thus its type is just int and can be used in any wider context (int i = int{3} will work and … Read more
I think the following could be a good guideline: If the (single) value you are initializing with is intended to be the exact value of the object, use copy (=) initialization (because then in case of error, you’ll never accidentally invoke an explicit constructor, which generally interprets the provided value differently). In places where copy … Read more
std::initializer_list is not a container, don’t use it to pass values around and expect them to persist DR 1290 changed the wording, you should also be aware of 1565 and 1599 which aren’t ready yet. Then the return value’s array should also survive into the calling function, and it should be possible to preserve it … Read more
How can I do what I want to do (that is, initialize an array in a constructor (not assigning elements in the body)). Is it even possible? Yes. It’s using a struct that contains an array. You say you already know about that, but then I don’t understand the question. That way, you do initialize … Read more