C++ Declaration and instantiation of scoped variable with curly braces instead of assignment operator

Question

I am watching Bjarne Stroustrup's Keynote on C++11 Style ( link ) (00:35:30) and am having troubles understanding the following (code copied from the slide):

void f(int n, int x)
{
      Gadget g {n};
      // ...
      if (x<100) throw std::run_time_error{"Weird!"};
      if (x<200) return;
      // ...
}

I tried compiling this code using a struct as well as an object but in both cases the compiler tells me that it is expecting a ';' at the end of the declaration of Gadget g and won't compile.

My questions therefore are:

• Am I correct to assume that g is being instantiated?
• What type of object must Gadget be for this code to compile?
• What concept is at work on this line: Gadget g {n}; ? ie What are the curly braces after the declaration?
• (probably too broad, but) Why would the compiler not recognize the curly braces as valid syntax?

Answer 1

Am I correct to assume that g is being instantiated?

Yes, you are correct.

What type of object must Gadget be for this code to compile?

Any type that can be initialized from an int . For instance, if your Gadget class has a constructor taking an int , or taking something that can be initialized directly from an int , that makes the code compile.

What concept is at work on this line: Gadget g {n}; ? ie What are the curly braces after the declaration?

That's uniform initialization syntax. It eliminates some nasty problem with the parentheses notation that would make the C++ compiler parse the following as a function declaration (rather than as the initialization of an object):

struct Widget { /* ... */ };
struct Gadget { Gadget(Widget const&) { /* ... */ } /* ... */ };

Gadget g(Widget()); // This is parsed a FUNCTION DECLARATION

In the above example, the intent of the programmer may have been to construct an object g of type Gadget and initialize it from a temporary Widget object: however, the compiler would parse this as the declaration of a function called g that returns a Gadget and takes as its argument a (pointer to a) function that accepts no arguments and returns a Widget . This is known as the Most Vexing Parse problem.

Notice, that when using braces the above problem does not exist:

Gadget g{Widget{}}; // This could not be possibly parsed as a function declaration!

(probably too broad, but) Why would the compiler not recognize the curly braces as valid syntax?

That's most likely because you are not using a C++11-compliant compiler. You should be using one, and use the -std=c++11 or -std=c++0x compilation flag to enable C++11 support.