Mastering Classes and Objects

• This is chapter 9
  • You should read it.
  • By the way, this is one of four chapters on classes.
• Access Control
  • Remember only objects of the same class have access to each other's private members.
  • Everything has access to an object's public members.
  • So what is the protected access specifier?
    • In chapter 10, we will find that classed derived from this class have access to the protected members.
• Friends
  • a friend function is a function that has been given access to the private and protected members of a class.
    • A reference
    • This involves the reserved word friend
    • This can be done for classes or functions.
• See friendDemo.cpp
• Meyers argument on Encapsulation
  • We make data private to make sure it is handled properly (via getters and setters)
  • We are building ADT
  • We have at least two goals
    • Protect our data from incorrect manipulation
    • Allow us to change the underlying implementation if needed.
  • Allowing unrestricted access to the data violates both of these.
  • Encapsulation involves hiding the implementation
    • Again so the implementation can be changed if needed but functionality maintained.
    • He argues that the fewer things that need adjusted if the implementation is changed, the more encapsulated an item is.
    • He is really saying that we should have as few functions with access to the data as possible.
  • He provides the following example
    • Assume you have a web browser class

    • class WebBrowser {
          public:
             void clearCache();
             void clearHistory();
             void removeCookies();
             ...
      }; 

    • Should void clearEverything(); be a member function?
    • Or should you have the function

    • void ClearWebBrowser(WebBrowser & wb) {
          wb.clearCache();
          wb.clearHistory();
          wb.removeCookies();
      } 

    • He argues that for encapsulation, the second is preferable.
      • a member function will add the possibility of another access to private data.
      • And it will not extend the functionality of the class at all.
  • Meyers is a huge fan of limiting member functions.
    • He would probably dislike my PersonT from last chapter.
  • No doubt, Meyers is opposed to protected data. (Effective c++, ch 22)
  • No doubt, Meyers is opposed to friend functions. (Effective c++, ch 23)
  • Your author also warns that friend functions should be used sparingly.
• I believe we can skip to page 251
  • The pages in between discuss dynamic memory.
  • They also address smart pointers.
  • We will go there eventually if we have time.