1.6.2 Brace Init

• Three ways to initialization:
  int x1 = 27;  //1) asiignment 
  int x2(27); //2) parentheses 
  int x3{ 27 }; //3) brace init 
  int x4={ 27 }; //same as 3
• Call default ctor.
  Widget w2(); // most vexing parse! declares a function 
   
  Widget w2; call default ctor 
  Widget w3{}; //use brace init to do .
• Initializing your objects, arrays, and containers is much easier in C++11 than it used to be in C++03. In C++03, below codes are impossible.
  vector <string> vs = {"alpha", "beta", "gamma"}; 
   
  map<string, string> stars = 
   { {"Superman", "+1␣(212)␣545-7890"}, 
    {"Batman", "+1␣(212)␣545-0987"}}; 
   
  double *pd= new double [3] {0.5, 1.2, 12.99}; 
  __________________________________________________________________//before { no =,  or compile error 
   
  class C { 
  int x[4]; 
  public: 
  C(): x{0,1,2,3} {} 
  };
• In C++11, This syntax was generalized, and any object type can now be created with a braced initializer list, known as a braced-init-list in the C++ grammar.
  auto p = new vector<string>{"foo", "bar"}; 
   
  //braced-init-list can be implicitly converted to a return type. 
  vector<int> test_function() { return {1, 2, 3}; } 
   
  // Iterate over a braced-init-list. 
  for (int i : {-1, -2, -3}) {} 
   
  // Call a function using a braced-init-list. 
  void TestFunction2(std::initializer_list<int> init_list) {} 
  TestFunction2({1, 2, 3});
• When brace init used as overload initializer_list, it always match initializer_list.
  class Widget { 
  public: 
  Widget(int i, bool b); // as before 
  Widget(int i, double d); // as before 
  Widget(std::initializer_list<long double> il); // added 
  }; 
   
  Widget w1(10, true); //  calls first ctor 
  Widget w1{10, true}; // std::initializer_list ctor 
  // (10 and true convert to long double) 
   
  Widget w2(10, 5.0); //  calls second ctor 
  Widget w2{10, 5.0}; // std::initializer_list ctor 
  // (10 and 5.0 convert to long double)

  Compilers’ determination to match braced initializers with constructors taking std::initializer_lists is so strong, it prevails even if the best-match std::initializer_list constructor can’t be called.

  class Widget { 
  public: 
  Widget(int i, double d); // as before 
  Widget(std::initializer_list<bool> il); // added 
  }; 
  Widget w2{10, 5.0}; // still match init_list, 
  //5.0 can’t be convert bool, so compile fail.
• Empty braces mean no arguments, that is to say you get default construction, not an empty std::initializer_list:
  Widget w1; // calls default ctor 
  Widget w2{}; // also calls default ctor 
  Widget w3(); // most vexing parse! declares a function! 
   
  Widget w4({}); // calls std::initializer_list ctor with empty list 
  Widget w5{{}}; // ditto
• An example from vector, () and init brace are different in meaning.
  std::vector<int> v1(10, 20); // use non-std::initializer_list 
  // ctor: create 10-element vector, all elements 20. 
   
  std::vector<int> v2{10, 20}; // use initializer_list ctor: 
  // create 2-element vector, element are 10 and 20
• base on previous vector example, choosing between parentheses and braces for object creation inside templates can be challenging.(it has different semantic meaning.)
• If you use a braced initialize list when initializing a variable, use an equals before the open curly brace.
• An empty pair of braces indicates default initialization. Default initialization of POD types usually means initialization to binary zeros, whereas for non-POD types default initialization means default constructor is invoked. You can omit = under such context.
  int x = {5}; // When use init, prefer to use = 
  string s2={s1}; 
  short quar[5] = {1,2,3,4,5} 
  class c1={3,"aaa"}; //Just like class c1(3,"aaa"); 
   
  int x{}; //x will be 0 
  char str[12]{}; all element will be ’\0’; 
  double y{5}; // you can omit =
• When you use Type{} to define a nameless temporary variable. don’t give variable name.
  1. In C++, anonymous variables are primarily used either to pass or return values without having to create lots of temporary variables to do so.
  2. anonymous objects are treated as rvalues (not lvalues, which have an address). This means anonymous objects can only be passed or returned by value or const reference. Otherwise, a named variable must be used instead.
  Cents add(const Cents &c1, const Cents &c2){ 
      return Cents(c1.getCents() + c2.getCents()); 
      // return anonymous Cents value 
  } 
   
  cout <<add(Cents{6}, Cents{8}).getCents();
• Uniform Initialization: It will stop narrow if it’s out of range of target. but allow if the value is within the range of the target.
• When use with auto, you need to be careful.
  auto d = {1.23}; 
  // d is a std::initializer_list<double> 
  auto d = double{1.23}; 
  // Good -- d is a double, not a std::initializer_list.