Initializing scalars with braces

Question

In C and C++, one can initialize arrays and structs using braces:

int a[] = {2, 3, 5, 7};
entry e = {"answer", 42};

However, in a talk from 2007, Bjarne mentions that this syntax also works for scalars. I tried it:

int i = {7};

And it actually works! What is the rationale behind allowing the initialization of scalars with braces?

Note: I am specifically not talking about C++11 uniform initialization. This is good old C89 and C++98.

Answer 1

What is the rationale behind allowing the initialization of scalars with braces?

int is POD. So the brace initialization is allowed in case of int (and for all build-in types), as it makes the initialization-syntax consistent with other PODs.

Also, I guess whatever rationale behind C++11 Uniform Initialization Syntax are, are also (partially) applicable to this syntax allowed by C++03. It is just C++03 didn't extend this to include non-pod types such as the standard containers.

I can see one place where this initialization is helpful in C++03.

template<typename T>
void f()
{
    T  obj = { size() } ; //T is POD: built-in type or pod-struct
    //code
}

Now this can be instantiated with struct which begins with a suitable member, as well as any arithmetic type:

struct header
{ 
    size_t size; //it is the first member
    //...
};

f<header>(); //body becomes : header obj = { size(); }; which is fine
f<size_t>(); //body becomes : size_t obj = { size(); }; which is fine

Also note that POD, whether struct or built-in types, can also be initialized uniformly as:

header h = header(); //value-initialized
int    i = int();    //value-initialized

So I believe one reason is consistency!

Answer 2

The rationale is not mentioned, but from a 2005 C++ Standard draft, 8.5 Initializers [dcl.init], clause 14

If T is a scalar type, then a declaration of the form T x = { a }; is equivalent to T x = a;

Note that the C++ 98 Standard only allows brace initializers for copy-initialization T x = { a }, and not for direct initialization T x { a }, for which only T x(a) works.

UPDATE: see also this question

Answer 3

C++ probably inherited this from C. In C the main reason is to have a unique initilizer syntax, in particular for a default initializer. In C the default initializer is {0}.