Initializer list vs. vector

initializer_list uses optimal storage location and prevents unnecessary calls, it's designed to be lightweight, while with vector there's a heap allocation and there may be more copies/moves made.

The semantics of the two are quite different. The initializer_list has pointer semantics while the vector has value semantics.

In your first example, the compiler will generate code similar to the following:

int const __temp_array[3] = {1, 2, 3}; cout << sumL(std::initializer_list<int>(__temp_array, __temp_array + 3)) << "\n"; 

This is explained in [dcl.init.list]/5. As you can see, within sumL you have access to const pointers to the elements of the braced-init-list, this means you have no other option but to copy the elements out of the list.

In case of sumV you could've std::moved the elements from the vector if needed (assuming the parameter type is not const).

Similarly, copying the initializer_list performs shallow copies, i.e. only the pointers will be copied, while copying the vector, of course, means the elements will be copied.

In your example, none of the points above really make any difference, other than constructing the vector will require dynamic memory allocation, while constructing the initializer_list will not.

initalizer_list is not a generalized container like std::vector. It's primary purpose is object initialization. If the low overheard and no heap allocation is attractive to you I'd suggest looking at std::array. It a fixed sized stack allocated array that has all the conveniences of a STL container, which is essentially a thin wrapper on top of a c-array.

I feel describing initializer_list as lightweight misses the point.

The initializer_list is (by necessity) handled by the compiler. Its definition does not include memory management or ownership, nor does it have a useful (non-blank) constructor, nor must it conform to any particular layout. The standard suggests its representation is basically pair of pointers (begin and end):

An object of type initializer_list provides access to an array of objects of type const E. [Note: A pair of pointers or a pointer plus a length would be obvious representations for initializer_list.]

And we can see elsewhere in the standard that initializer_list is generally used as if something had happened, but does not actually require anything concrete::

An object of type std::initializer_list is constructed from an initializer list as if the implementation generated and materialized a prvalue of type “array of N const E”

Allocation, initialisation and teardown of members, if required, is added by the compiler, and has nothing to do with the list itself.

Contrast this with a vector that can be modified on demand, performs memory management, and actually owns the objects inside the array, mandating that they exist in the heap.

As to which to use, it depends on the circumstances, in the example above I'd use the initializer list, since it would seem simpler. However I'd believe a vector could be more efficient if I were moving contents into my own vector (and I could therefore simply use std::move), or if I believed the user would likley already be starting out with their own vector, and I could therefore avoid an unnecessary intermediate.

Initializer lists

A lightweight array-like container of elements created using a "braced list" syntax. For example, { 1, 2, 3 } creates a sequences of integers, that has type std::initializer_list. Useful as a replacement to passing a vector of objects to a function.

 int sum(const std::initializer_list<int>& list) { int total = 0; for (auto& e : list) { total += e; } return total; } auto list = {1, 2, 3}; sum(list); // == 6 sum({1, 2, 3}); // == 6 sum({}); // == 0 

However, in your case if you will do it the way you are doing compiler likely to optimize it the same way as you can see the vector function implementation mentioned below.

template <class T> struct S { std::vector<T> v; S(std::initializer_list<T> l) : v(l) { std::cout << "constructed with a " << l.size() << "-element list\n"; } void append(std::initializer_list<T> l) { v.insert(v.end(), l.begin(), l.end()); } std::pair<const T*, std::size_t> c_arr() const { return {&v[0], v.size()}; // copy list-initialization in return statement // this is NOT a use of std::initializer_list } };