Indeed the final version of C++11 does not enable the use of initializer lists on the right-hand side (or left-hand side, for that matter) of a binary operator. Firstly, initializer-lists are not expressions as defined in ยง5 of the Standard. The arguments of functions, as well as of binary operators, generally have to be expressions, … Read more
According to Bjarne Stroustrup in Section 17.3.4.2 (p. 497) of The C++ Programming Language, 4th Edition: Unfortunately, initializer_list doesn’t provide subscripting. No further reason is given. My guess is that it’s one of these reasons: it’s an omission, or because the initializer_list class is implemented with an array and you’d have to do bounds checking … Read more
In general, is there a way to do this without wasted function calls or memory? Yes. This can be done with a delegating constructor, introduced in C++11. A delegating constructor is a very efficient way to acquire temporary values needed for construction before any member variables are initialized. int gcd(int a, int b); // Greatest … Read more
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
What is happening here is that in the two element initializer list both of the string literals can be implicitly converted to const char* since their type is const char[N]. Now std::vector has a constructor that takes two iterators which the pointers qualify for. Because of that the initializer_list constructor of the std::vector<std::string> is conflicting … 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
Use the appropriate constructor, which takes a size and a default value. int number_of_elements = 10; int default_value = 1; std::vector<int> vec(number_of_elements, default_value);
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
The standard committee seems to intend on initializer_list being a literal type. However, it doesn’t look like it’s an explicit requirement, and seems to be a bug in the standard. From ยง 3.9.10.5: A type is a literal type if it is: – a class type (Clause 9) that has all of the following properties: … Read more
The answer is NO, you cannot do that. An object of type std::initializer_list<T> is a lightweight proxy object that provides access to an array of objects of type T. A std::initializer_list object is automatically constructed when: a braced-init-list is used in list-initialization, including function-call list initialization and assignment expressions (not to be confused with constructor … Read more