Chapter 8 Part 1

• I am going to start working through chapter 8.
  • We will focus on the things that are new to us.
  • But you should read the entire chapter.
  • You will pick up new material.
• One piece from I am not sure where.
  • Curly brace initializer lists.
  • See this page for a reference.
    • This was introduced in C++11
    • It is an alternative to initializations of the form int a = 0;
    • int a{0}
  • It is apparently a good thing.
    • This is supposed to work in all cases, = does not.
    • It does not allow type narrowing.
  • Take a look at the examples in initList.cpp
• We will discuss protected access control in the near future.
• In-class member initializers are a good thing.
  • They are one of the three ways to initialize class member data.
  • They are probably preferred for default values.

    private:
       int data{4};
       string word{"hello"} 

• He goes on to discuss the object lifecycle
• Constructors
  • Sometimes called a ctor
  • A constructor that can be called without arguments is called the default constructor
    • Either no parameters
    • Or all parameters have default values.
    • You need a default constructor any time you will build an instance of the class without being able to supply arguments.
      • An array of elements.
      • A presized vector.
    • you can force the compiler to write a constructor

      • class FooT {
            public:
               FooT() = default;
        } 

    • As we have seen you can also prohibit the compiler from creating a constructor.

    • class FooT {
          public:
             FooT() = delete;
      } 

  • Under most conditions if there is no default constructor, the compiler will build one for you
  • Constructor initializers
    • ctor-initializers.
    • When a class is constructed
      • All component data members are allocated/constructed
      • This means component constructors are called BEFORE the class constructor.
      • The constructor for the containing object is only called after all of this occurs.
      • This means objects can be "assigned twice"
        • Once when constructed
        • Again in the constructor of the containing object.
      • It is even a bigger problem with contained classes with no default constructor.
    • There is also a problem with inheritance, but that is for chapter 10.
    • Ctor initializers
      • Are given between the constructor argument list and the body of the constructor.
      • Are a comma separated list of the data members
        • Given in the order they are declared
        • With values in parenthesis.
        • The values can include parameter values.
      • Note, items are initialized in the order they are declared in the class.
        • Not the order they are listed in the constructor.
      • See ctorInit.cpp