Why use initializer_list instead of vector in parameters?

Well, std::vector has to use initializer_list to get that syntax as it obviously can't use itself.

Anyway, initializer_list is intended to be extremely lightweight. It can use an optimal storage location and prevent unnecessary copies. With vector, you're always going to get a heap allocation and have a good chance of getting more copies/moves than you want.

Also, the syntax has obvious differences. One such thing is template type deduction:

struct foo {
    template<typename T>  
    foo(std::initializer_list<T>) {}
};

foo x{1,2,3}; // works

vector wouldn't work here.

The biggest advantage of initializer_list over vector is that it allows you to specify in-place a certain sequence of elements without requiring delicate processing to create that list.

This saves you from setting up several calls to push_back (or a for cycle) for initializing a vector even though you know exactly which elements are going to be pushed into the vector.

In fact, vector itself has a constructor accepting an initializer_list for more convenient initialization. I would say the two containers are complementary.

// v is constructed by passing an initializer_list in input
std::vector<std::string> v = {"hello", "cruel", "world"};

Of course it is important to be aware of the fact that initializer_list does have some limitations (narrowing conversions are not allowed) which may make it inappropriate or impossible to use in some cases.

Sometimes all you require is an array of values (instead of a vector, say), but you also need to know how long the array is. Passing the type as initializer_list sure makes it easy to pass the length:

void g(const int arr[], size_t n);  // outside of my control

void f(initialize_list<int> values) {  // test code under my control
  const int* const arr = values.begin();
  const int n = values.size();
  g(arr, n);  // why I need to know arr len
  // ...
}

Then you can say:

f({1,2,3});  // some static test case

Any other alternative declaration of f will cause some pain:

• if you were to declare function f to accept a normal array as the parameter type, you'd have to pass both the array (pointer) and its length, either dynamically as an additional parameter (as in function g), or statically by making function f a template
• if you were to declare the parameter as a vector, then you'd be dynamically constructing a separate object merely to know the number of items, when you already know the length statically

To reiterate the point: sometimes you have a generic set of values that you need to pass to a function, and it's convenient to pass these values using std::initializer_list, since this allows the programmer to preserve information (the cardinality of the set) known at the time of compilation.

To be sure, passing the set of values as a std::vector is more general, but sometimes you don't need that full generality.

I would like to point out one drawback of std::initializer_list in comparison with std::vector.

Suppose we have the function f with std::initializer_list parameter. This function can accept variable number of elements (call f ({"cat", "dog", "parrot"}); in code below) - this is OK.

Some day, we may want this function to process elements not only from braced-enclosed initializer list, but also from some container (see vector vec in code below). Then, as far as I know, there is no (no easy?) way to do this (see here).

#include <initializer_list>
#include <iostream>
#include <string>
#include <vector>

void f (std::initializer_list<std::string> input_list)
{
    for (const auto & current_element : input_list)
        std::cout << current_element << std::endl;
}

int main()
{
    f ({"cat", "dog", "parrot"});

    std::vector<std::string> vec {"cow", "horse", "pig"};
    //No way (no simple way?) to pass elements from vec to f

    return 0;
}

At the same time, if we create function g with const std::vector<std::string> & parameter, it is capable of accepting both braced-enclosed initializer lists and elements from containers.