Can't Define an initializer_list in cbegin

Question

So I can do this:

for(const auto i : { 13, 42 }) cout << i << ' ';

But I can't do this:

copy_n(cbegin({ 13, 42 }), 2, ostream_iterator<int>(cout, " "));

It gives me the error:

error: no matching function for call to cbegin(<brace-enclosed initializer list>)

What is it about the for-statement that allows this but not the cbegin function?

Edit:

It appears that the problem is that my initializer_list isn't being treated as an initializer_list, because if I do this it works:

copy_n(cbegin(initializer_list<int>{ 13, 42 }), 2, ostream_iterator<int>(cout, " "));

Live Example

Answer 1

{ 13, 42 } is braced initializer list. It doesn't have a type, it is just a list and it depends on how it used as how it gets treated. std::cbegin is defined like

template< class C > 
constexpr auto cbegin( const C& c ) -> decltype(std::begin(c));

and since the braced initializer list doesn't have a type, the template type deduction fails. In the ranged based for loop we use the list different. A range based for loop expands to

{
    init-statement
    auto && __range = range_expression ; 
    auto __begin = begin_expr ;
    auto __end = end_expr ;
    for ( ; __begin != __end; ++__begin) { 
        range_declaration = *__begin; 
        loop_statement 
    } 
} 

with auto && __range = range_expression ; becoming auto && __range = { 13, 42 }. Now auto follows template type deduction except that since the committee decide that auto should work with braced initializer list, auto will deduce { 13, 42 } to a std::initiaizer_list<int> since the list contains only ints.

---

If you change the code to

copy_n(begin({ 13, 42 }), 2, ostream_iterator<int>(cout, " "));

even though std::begin is defined like cbegin and takes a template type, <initializer_list> introduces an overload that takes a std::initializer_list and that will get called instead.

Answer 2

Initializer list stores only pointers to the original list and by design it does not allow the user to modify the data, i.e.

const T* begin(); // returns a constant object

So the begin member or a begin free-function would be equivalent to cbegin. That is why only begin exists.

Update

Concerning cbegin(std::initializer_list<int>...: that works because you explicitly specified the type and cbegin(const Container&... is actually a template function, and begin(std::initializer_list<U>... is a different template function, as I said in the first part of the answer there is no cbegin(std::initializer_list<U>... function.

And the solving part is that you cannot do "chained" template deduction, it does not make sense: Container -> std::initializer_list<U> -> std::initializer_list<int>. Only one of the two deduction might exist, either Container -> std::initializer_list<int>, or std::initializer_list<U> -> std::initializer_list<int>