c++ - Why does 'std::vector b{2};' create a 1-element vector, and not a 2-element one?

I've been playing around with C++11 for the past few days, and I came up with something strange.

If I want to uniformly initialize an int:

int a{5};

But if I do the same thing to a std::vector:

std::vector b{2};

Does not construct a two element array, but rather an array with one element of value two. It seems like to get that effect one would need to be more explicit about it:

std::vector c{{2}};
std::vector d = {2};

But not like the declaration of b - this seems inconsistent. I have seen some other stuff to the same effect. What I'm asking - is this behavior in the final C++11 standard, or is it just in a draft that was implemented early? If so, why did the standards committee include this behavior? It seems like it defeats the whole purpose of uniform initialization, as one has to remember which classes have initializer list constructors, and to use the old () syntax instead of {} with just those classes. Or one forgoes uniform initialization altogether.

This seems like a big "gotcha". But there might be advantages to it that I am not aware of.

Edit: this code:

#include 
#include 


int main() {
    std::vector a{2};
    for (auto x: a) {
        std::cout << x << std::endl;
    }
    return 0;
}

outputs "2" on gcc 4.6.2

Answer

Yes, this behaviour is intended, according to §13.3.1.7 Initialization by list-initialization

When objects of non-aggregate class type T are list-initialized
(8.5.4), overload resolution selects the constructor in two phases:

— Initially, the candidate functions are the initializer-list
constructors (8.5.4) of the class T and the argument list consists of

the initializer list as a single argument.

— If no viable
initializer-list constructor is found, overload resolution is
performed again, where the candidate functions are all the
constructors of the class T and the argument list consists of the
elements of the initializer list.

As to "the whole purpose of uniform intialization"... "Uniform initialization" is a marketing term, and not a very good description. The standard has all the usual forms of initialization plus list-initialization, but no "uniform initialization". List initialization is not meant to be the ultimate form of initialization, it's just another tool in the utility belt.