Can I initialize an STL vector with 10 of the same integer in an initializer list?  My attempts so far have failed me.

Can I initialize an STL vector with 10 of the same integer in an initializer list?

If I have two different constant members variables, which both need to be initialized based on the same function call, is there a way to do this without calling the function twice? 

For example, a fraction class where numerator and denominator are constant.
```
int gcd(int a, int b); // Greatest Common Divisor
class Fraction {
public:
    // Lets say we want to initialize to a reduced fraction
    Fraction(int a, int b) : numerator(a/gcd(a,b)), denominator(b/gcd(a,b))
    {

    }
private:
    const int numerator, denominator;
};
```

This results in wasted time, as the GCD function is called twice. You could also define a new class member, `gcd_a_b`, and first assign the output of gcd to that in the initializer list, but then this would lead to wasted memory.

In general, is there a way to do this without wasted function calls or memory? Can you perhaps create temporary variables in an initializer list?

Initialize multiple constant class members using one function call C++

Why do I receive the error &quot;Variable-sized object may not be initialized&quot; with the following code? 

    int boardAux[length][length] = {{0}};

C compile error: &quot;Variable-sized object may not be initialized&quot;

    class C 
    {
    public:
     C() : arr({1,2,3}) //doesn&#39;t compile
    {}
        /*
        C() : arr{1,2,3} //doesn&#39;t compile either
    {}
        */
    private:
     int arr[3];
    };


I believe the reason is that arrays can be initialized only with `=` syntax, that is:

    int arr[3] = {1,3,4};

### Questions

 1. 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?   
 2. Does the C++03 standard say anything special about initializing aggregates (including arrays) in ctor initializers? Or the invalidness of the above code is a corollary of some other rules?  
 3. Do C++0x initializer lists solve the problem?

***P.S.*** Please do not mention vectors, boost::arrays, and their superiority to arrays, which I am well aware of.



Initializing a member array in constructor initializer

If I pass the following code through my GCC 4.7 snapshot, it tries to copy the `unique_ptr`s into the vector.

    #include &lt;vector&gt;
    #include &lt;memory&gt;
    
    int main() {
        using move_only = std::unique_ptr&lt;int&gt;;
        std::vector&lt;move_only&gt; v { move_only(), move_only(), move_only() };
    }

Obviously that cannot work because `std::unique_ptr` is not copyable:

&gt; error: use of deleted function &#39;std::unique_ptr&lt;_Tp, _Dp&gt;::unique_ptr(const std::unique_ptr&lt;_Tp, _Dp&gt;&amp;) [with _Tp = int; _Dp = std::default_delete&lt;int&gt;; std::unique_ptr&lt;_Tp, _Dp&gt; = std::unique_ptr&lt;int&gt;]&#39;

Is GCC correct in trying to copy the pointers from the initializer list?

Can I list-initialize a vector of move-only type?

Am I allowed to move elements out of a `std::initializer_list&lt;T&gt;`?

    #include &lt;initializer_list&gt;
    #include &lt;utility&gt;

    template&lt;typename T&gt;
    void foo(std::initializer_list&lt;T&gt; list)
    {
        for (auto it = list.begin(); it != list.end(); ++it)
        {
            bar(std::move(*it));   // kosher?
        }
    }

Since `std::intializer_list&lt;T&gt;` requires special compiler attention and does not have value semantics like normal containers of the C++ standard library, I&#39;d rather be safe than sorry and ask.

initializer_list and move semantics

In C++11, we have that new syntax for initializing classes which gives us a big number of possibilities how to initialize variables.

    { // Example 1
      int b(1);
      int a{1};
      int c = 1;
      int d = {1};
    }
    { // Example 2
      std::complex&lt;double&gt; b(3,4);
      std::complex&lt;double&gt; a{3,4};
      std::complex&lt;double&gt; c = {3,4};
      auto d = std::complex&lt;double&gt;(3,4);
      auto e = std::complex&lt;double&gt;{3,4};
    }
    { // Example 3
      std::string a(3,&#39;x&#39;);
      std::string b{3,&#39;x&#39;}; // oops
    }
    { // Example 4
      std::function&lt;int(int,int)&gt; a(std::plus&lt;int&gt;());
      std::function&lt;int(int,int)&gt; b{std::plus&lt;int&gt;()};
    }
    { // Example 5
      std::unique_ptr&lt;int&gt; a(new int(5));
      std::unique_ptr&lt;int&gt; b{new int(5)};
    }
    { // Example 6
      std::locale::global(std::locale(&quot;&quot;)); // copied from 22.4.8.3
      std::locale::global(std::locale{&quot;&quot;});
    }
    { // Example 7
      std::default_random_engine a {}; // Stroustrup&#39;s FAQ
      std::default_random_engine b;
    }
    { // Example 8
      duration&lt;long&gt; a = 5; // Stroustrup&#39;s FAQ too
      duration&lt;long&gt; b(5);
      duration&lt;long&gt; c {5};
    }

For each variable I declare, I have to think which initializing syntax I should use and this slows my coding speed down. I&#39;m sure that wasn&#39;t the intention of introducing the curly brackets.

When it comes to template code, changing the syntax can lead to different meanings, so going the right way is essential.

I wonder whether there is a universal guideline which syntax one should chose.


When to use the brace-enclosed initializer?

Why isn&#39;t `std::initializer_list` a core-language built-in?
---------------------------------------------------------------

It seems to me that it&#39;s quite an important feature of C++11 and yet it doesn&#39;t have its own reserved keyword (or something alike).

Instead, `initializer_list` it&#39;s *just* a template class from the standard library that has a special, implicit *mapping* from the new *braced-init-list* `{...}` syntax that&#39;s handled by the compiler.

At first thought, this solution is quite *hacky*.

Is this the way new additions to the C++ language will be now implemented: by **implicit roles** of some template classes and not by the **core** language?

---
**Please consider these examples:**

       widget&lt;int&gt; w = {1,2,3}; //this is how we want to use a class

why was a new class chosen:

       widget( std::initializer_list&lt;T&gt; init )

instead of using something **similar** to any of these ideas:

       widget( T[] init, int length )  // (1)
       widget( T... init )             // (2)
       widget( std::vector&lt;T&gt; init )   // (3)

1. a classic array, you could probably add `const` here and there
2. three dots already exist in the language (var-args, now variadic templates), why not re-use the syntax (and make it feel *built-in*)
3. just an existing container, could add `const` and `&amp;`

All of them are already a part of the language. I only wrote my 3 first ideas, I am sure that there are **many** other approaches.

Why isn&#39;t std::initializer_list a language built-in?

If it even exists, what would a `std::map` extended initializer list look like?

I&#39;ve tried some combinations of... well, everything I could think of with GCC 4.4, but found nothing that compiled.


What would a std::map extended initializer list look like?

Everyone creates `std::vector` from `std::initializer_list`, but what about the other way around?

eg. if you use a `std::initializer_list` as a parameter:

    void someThing(std::initializer_list&lt;int&gt; items)
    {
    ...
    }

There are times when you have your items in a `vector&lt;T&gt;` instead of a literal list:

    std::vector&lt;int&gt; v;
    // populate v with values
    someThing(v); // boom! No viable conversion etc.

The more general question is: how to create an `stl::initializer_list` from a STL iterable, not just `std::vector`.

Convert a vector&lt;T&gt; to initializer_list&lt;T&gt;

I tracked down an obscure logging bug to the fact that initializer lists of length 2 appear to be a special case!  How is this possible?

The code was compiled with Apple LLVM version 5.1 (clang-503.0.40), using `CXXFLAGS=-std=c++11 -stdlib=libc++`.


    #include &lt;stdio.h&gt;

    #include &lt;string&gt;
    #include &lt;vector&gt;

    using namespace std;

    typedef vector&lt;string&gt; Strings;

    void print(string const&amp; s) {
        printf(s.c_str());
        printf(&quot;\n&quot;);
    }

    void print(Strings const&amp; ss, string const&amp; name) {
        print(&quot;Test &quot; + name);
        print(&quot;Number of strings: &quot; + to_string(ss.size()));
        for (auto&amp; s: ss) {
            auto t = &quot;length = &quot; + to_string(s.size()) + &quot;: &quot; + s;
            print(t);
        }
        print(&quot;\n&quot;);
    }

    void test() {
        Strings a{{&quot;hello&quot;}};                  print(a, &quot;a&quot;);
        Strings b{{&quot;hello&quot;, &quot;there&quot;}};         print(b, &quot;b&quot;);
        Strings c{{&quot;hello&quot;, &quot;there&quot;, &quot;kids&quot;}}; print(c, &quot;c&quot;);

        Strings A{&quot;hello&quot;};                    print(A, &quot;A&quot;);
        Strings B{&quot;hello&quot;, &quot;there&quot;};           print(B, &quot;B&quot;);
        Strings C{&quot;hello&quot;, &quot;there&quot;, &quot;kids&quot;};   print(C, &quot;C&quot;);
    }

    int main() {
        test();
    }


Output:

    Test a
    Number of strings: 1
    length = 5: hello

    Test b
    Number of strings: 1
    length = 8: hello

    Test c
    Number of strings: 3
    length = 5: hello
    length = 5: there
    length = 4: kids

    Test A
    Number of strings: 1
    length = 5: hello

    Test B
    Number of strings: 2
    length = 5: hello
    length = 5: there

    Test C
    Number of strings: 3
    length = 5: hello
    length = 5: there
    length = 4: kids

I should also add that the length of the bogus string in test b seems to be indeterminate - it&#39;s always greater than the first initializer string but has varied from one more than the length of the first string to the total of the lengths of the two strings in the initializer. 

C++11 initializer list fails - but only on lists of length 2

With the C++14 standard, the initialization of an `std::array` can go with single braces (see http://en.cppreference.com/w/cpp/container/array):

This, however, does not work for an `std::array` of `std::pair`. 

Why do these work:

    std::pair&lt;int, int&gt; p { 1, 2 };
    std::array&lt;int, 3&gt; a {1, 2, 3};

but does this *not* work:

    std::array&lt;std::pair&lt;int, int&gt;, 3&gt; b {{1, 11}, {2, 22}, {3, 33}};

while this does work again?

    std::array&lt;std::pair&lt;int, int&gt;, 3&gt; b {{{1, 11}, {2, 22}, {3, 33}}};

Also, for completion, the initialization of a good old array does work with single braces

    std::pair&lt;int, int&gt; c[3] {{1, 11}, {2, 22}, {3, 33}};

Why does initialization of array of pairs still need double braces in C++14?

This is a follow-up of this question: [Is it legal to declare a constexpr initializer_list object?](https://stackoverflow.com/questions/16063123/is-it-legal-to-declare-a-constexpr-initializer-list-object).

Since C++14, the `std::initializer_list` class has all of its methods marked with `constexpr`. It seems natural to be able to initialize an instance by doing 
`constexpr std::initializer_list&lt;int&gt; list = {1, 2, 3};` 
but Clang 3.5 complains about `list` not being initialized by a constant expression. 
[As dyp pointed out in a comment](https://stackoverflow.com/questions/16063123/is-it-legal-to-declare-a-constexpr-initializer-list-object#comment43416424_16067393), any requirement for `std::initializer_list` to be a literal type seem to have vanished from the specs.

What&#39;s the point of having a class fully defined as constexpr if we can&#39;t even initialize it as such? Is it an oversight in the standard and will get fixed in the future?

Why isn&#39;t `std::initializer_list` defined as a literal type?

I&#39;m getting up to speed with C++0x, and testing things out with g++ 4.6

I just tried the following code, thinking it would work, but it doesn&#39;t compile. I get the error:

`incompatible types in assignment of ‘std::initializer_list&lt;const int&gt;’ to ‘const int [2]’`


    struct Foo
      {
        int const data[2];

        Foo(std::initializer_list&lt;int const&gt;&amp; ini)
        : data(ini)
        {}
      };

    Foo f = {1,3};


How do I initialize a member array with an initializer_list?

I love `auto` in C++11. It&#39;s wonderful. But it has one inconsistency that really gets on my nerves, because I trip over it all the time:

    int i = 3;       // i is an int with value 3
    int i = int{3};  // i is an int with value 3
    int i(3);        // i is an int with value 3 (possibly narrowing, not in this case)
    int i{3};        // i is an int with value 3

    auto i = 3;      // i is an int with value 3
    auto i = int{3}; // i is an int with value 3
    auto i(3);       // i is an int with value 3
    auto i{3};       // wtf, i is a std::initializer_list&lt;int&gt;?!

This strange behaviour is confusing for newcomers, and annoying for experienced users -- C++ has enough little inconsistencies and corner cases that one has to keep in mind as it is. Can anybody explain why standards committee decided to introduce a new one in this case?

I could understand it if declaring a variable of type `std::initializer_list` was something that was useful or done frequently, but in my experience it&#39;s almost never deliberate -- and in the rare cases where you did want to do it, any of

    std::initializer_list&lt;int&gt; l{3};
    auto l = std::initializer_list&lt;int&gt;{3};
    auto l = {3}; // No need to specify the type

would work just fine. So what&#39;s the reason behind the special case for `auto x{i}`?

Why does auto x{3} deduce an initializer_list?

Why are the first two calls to `doSomething` OK by the compiler, but using two elements in the list causes an ambiguous call?

    #include &lt;vector&gt;
    #include &lt;string&gt;

    void doSomething(const std::vector&lt;std::string&gt;&amp; data) {}

    void doSomething(const std::vector&lt;int&gt;&amp; data) {}

    int main(int argc, char *argv[])
    {
        doSomething({&quot;hello&quot;}); // OK
        doSomething({&quot;hello&quot;, &quot;stack&quot;, &quot;overflow&quot;}); // OK
        doSomething({&quot;hello&quot;, &quot;stack&quot;}); // C2668 &#39;doSomething&#39;: ambiguous call

        return 0;
    }


All Initializer List Solutions on Gang of Coders

Total of 16 Initializer List Solutions

Can I initialize an STL vector with 10 of the same integer in an initializer list?

Initialize multiple constant class members using one function call C++

C compile error: "Variable-sized object may not be initialized"

Initializing a member array in constructor initializer

Can I list-initialize a vector of move-only type?

initializer_list and move semantics

When to use the brace-enclosed initializer?

Why isn't std::initializer_list a language built-in?

What would a std::map extended initializer list look like?

Convert a vector<T> to initializer_list<T>

C++11 initializer list fails - but only on lists of length 2

Why does initialization of array of pairs still need double braces in C++14?

Why isn't `std::initializer_list` defined as a literal type?

How do I initialize a member array with an initializer_list?

Why does auto x{3} deduce an initializer_list?

Why does the number of elements in a initializer list cause an ambiguous call error?