Uniform initialization in C++0x, when to use () instead of {}?

Question

Hi,

Is there a rule of thumb to decide when to use the old syntax () instead of the new syntax {}?

To initialize a struct:

struct myclass
{
    myclass(int px, int py) : x(px), y(py) {}
private:
    int x, y;
};
...
myclass object{0, 0};

Now in the case of a vector for example, it has many constructors. Whenever I do the following:

vector<double> numbers{10};

I get a vector of 1 element instead of one with 10 elements as one of the constructors is:

explicit vector ( size_type n, const T& value= T(), const Allocator& = Allocator() );

My suspicion is that whenever a class defines an initializer list constructor as in the case of a vector, it gets called with the {} syntax.

So, is what I am thinking correct. i.e. Should I revert to the old syntax only whenever a class defines an initializer list constructor to call a different constructor? e.g. to correct the above code:

vector<double> numbers(10); // 10 elements instead of just one element with value=10

Answer 1

Take a look at this:

http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=453&rll=1

The use of a {}-style initializers on a variable has no direct mapping to the initialization lists on any constructors of the class. Those constructor initialization lists can be added/removed/modified without breaking existing callers.

Basically the different behavior of the container is special, and requires special code in that container, specifically a constructor taking a std::initializer_list. For POD and simple objects, you can use {} and () interchangeably.

Answer 2

I've found the answer in the standard docs(latest draft). Hopefully, I'll try to explain what I understood.

First, if a class defines an initialization list constructor, then it is used whenever suitable:

§ 8.5.4 (page 203)

Initializer-list constructors are favored over other constructors in list-initialization (13.3.1.7).

I think this is a great feature to have, eliminating the headache associated with the non-uniform style :)

Anyway, the only gotcha(which my question is about) is that if you design a class without the initializer constructor, then you add it later you may get surprising result.

Basically, imagine std::vector didn't have the initializer list constructor, then the following would create a vector with 10 elements:

std::vector<int> numbers{10};

By adding the initializer list constructor, the compiler would favor it over the other constructor because of the {} syntax. This behavior would happen because the elements of the init-list {10} are accepted using the init-list constructor. If there is no acceptable conversion, any other constructor shall be used e.g.:

std::vector<string> vec{10};
// a vector of 10 elements.
// the usual constructor got used because "{0}"
// is not accepted as an init-list of type string.