Chapter 8, Gaining Proficiency with Classes and Objects

• We will not linger here long.
  • But there are some ideas we should pick up.
  • You should read the chapter.
• Access Control:
  • private: only instances of the class may access private members.
  • public: anything may access public members.
  • protected: instances of the class, and instances of a derived class have access to protected members.
  • Take a look at the table on page 341.
  • You may intersperse public, private and protected "sections" of a class in any order, even multiple times.

  • class SillyT {
       public: 
          SillyT();
       private 
          int x;
       public:
          SillyT(const SillyT & other);
       protected:
          void CopyMemory();
       ...
    } 

• Constructors
  • These are sometimes c-tors
  • We have discussed default constructors.
    • The constructor that takes no parameters.
    • You should usually have a default constructor.
  • Constructor initializers
    • Data members for a class are created BEFORE the constructor is called.
    • If we have something like a reference, or a component class without a default constructor, then we have a problem.
  • The three ways to initialize/set values class of members
    • In the constructor
      • This is dynamic
      • But it is not initialization of class members, it is assignment.

      • class FooT {
            private:
                int x;
                string word;
                ...
        FooT::FooT(int xval) {
            x = xval;
            word = "hello";
        } 

    • In the declaration
      • But this is not dynamic

      • class FooT {
            private:
                int x{7};
                string word{"Hello"};
        
        } 

    • As a c-tor initializer

      • class FooT {
            private:
                int x;
                string word;
                ...
        FooT::FooT(int xval): x{xval}, word{"hello"} {} 

• C-tor initializers
  • ARE the time of construction of the member values.
  • They can be dynamic or static.
  • MUST BE DONE IN THE ORDER VARIABLES ARE DECLARED.
    • Members are created in the order they are declared,
    • NOT the order they are listed in the constructor initializor.
• Take a look at initialize.cpp
• Try switching the order of the variable initialization.
• constructor initializers are for
  • constant initialization with dynamic values.
  • Class construction with dynamic values.
  • reference class member initialization.
  • Used in inheritance.
• There is a discussion of copy constructors, but we are fairly good there.
• There is a discussion of destructors.
• And assignment operators.
• Since c++11, If you have a destructor or overloaded assignment operator the compiler will not write a copy constructor.