Question: What is the actual benefit and purpose of `initializer_list`, for unknown number of parameters? Why not just use `vector` and be done with it?

In fact, it sounds like just a `vector` with another name. Why bother?

The only "benefit" I see of `initializer_list` is that it has `const` elements, but that doesn't seem to be a reason enough to invent this whole new type. (You can just use a `const vector` after all.)

So, what am I mising?

Answer: 
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.