added ex7_16 ~ ex7_22

ch07/README.md

@@ -35,3 +35,51 @@ Sales_data() : units_sold(0) , revenue(0){}
 ```
 
 ## [Exercise 7.15](ex7_15.h)
+
+## Exercise 7.16
+
+There are no restrictions on how often an access specifier may appear.The specified
+access level remains in effect until the next access specifier or the end of the class body.
+
+The members which are accessible to all parts of the program should define after a public specifier.
+
+The members which are accessible to the member functions of the class but are not accessible to code that uses the class should define after a private specifier.
+
+## Exercise 7.17
+
+The only difference between using `class` and using `struct` to define a class is the default access level. (`class` : private, `struct` : public)
+
+## Exercise 7.18
+
+encapsulation is the separation of implementation from interface. It hides the implementation details of a type. (In C++, encapsulation is enforced by putting the implementation in the private part of a class)
+
+-----
+
+Important advantages:
+
+- User code cannot inadvertently corrupt the state of an encapsulation object.
+- The implementation of an encapsulated class can change over time without requiring changes in user-level code.
+
+## Exercise 7.19
+
+public include: constructors, `getName()`, `getAddress()`.
+private include: `name`, `address`.
+
+the interface should be defined as public, the data shouldn't expose to outside of the class.
+
+## Exercise 7.20
+
+`friend` is a mechanism by which a class grants access to its nonpublic members. They have the same rights as members.
+
+**Pros**:
+- the useful functions can refer to class members in the class scope without needing to explicitly prefix them with the class name.
+- you can access all the nonpublic members conveniently.
+- sometimes, more readable to the users of class.
+
+**Cons**:
+- lessens encapsulation and therefore maintainability.
+- code verbosity, declarations inside the class, outside the class.
+
+## [Exercise 7.21](ex7_21.h)
+
+## [Exercise 7.22](ex7_22.h)

ch07/ex7_21.h

@@ -0,0 +1,65 @@
+//
+//  ex7_21.h
+//  Exercise 7.21
+//
+//  Created by pezy on 11/13/14.
+//  Copyright (c) 2014 pezy. All rights reserved.
+//
+
+#ifndef CP5_ex7_21_h
+#define CP5_ex7_21_h
+
+#include <string>
+#include <iostream>
+
+class Sales_data {
+    friend std::istream &read(std::istream &is, Sales_data &item);
+    friend std::ostream &print(std::ostream &os, const Sales_data &item);
+    friend Sales_data add(const Sales_data &lhs, const Sales_data &rhs);
+
+public:
+    Sales_data() = default;
+    Sales_data(const std::string &s):bookNo(s) {}
+    Sales_data(const std::string &s, unsigned n, double p):bookNo(s),units_sold(n),revenue(n*p){}
+    Sales_data(std::istream &is) { read(is, *this);}
+
+    std::string isbn() const { return bookNo; };
+    Sales_data& combine(const Sales_data&);
+
+private:
+    std::string bookNo;
+    unsigned units_sold = 0;
+    double revenue = 0.0;
+};
+
+// member functions.
+Sales_data& Sales_data::combine(const Sales_data& rhs)
+{
+    units_sold += rhs.units_sold;
+    revenue += rhs.revenue;
+    return *this;
+}
+
+// friend functions
+std::istream &read(std::istream &is, Sales_data &item)
+{
+    double price = 0;
+    is >> item.bookNo >> item.units_sold >> price;
+    item.revenue = price * item.units_sold;
+    return is;
+}
+
+std::ostream &print(std::ostream &os, const Sales_data &item)
+{
+    os << item.isbn() << " " << item.units_sold << " " << item.revenue;
+    return os;
+}
+
+Sales_data add(const Sales_data &lhs, const Sales_data &rhs)
+{
+    Sales_data sum = lhs;
+    sum.combine(rhs);
+    return sum;
+}
+
+#endif

ch07/ex7_22.h

@@ -0,0 +1,43 @@
+//
+//  ex7_22.h
+//  Exercise 7.22
+//
+//  Created by pezy on 11/13/14.
+//  Copyright (c) 2014 pezy. All rights reserved.
+//
+
+#ifndef CP5_ex7_22_h
+#define CP5_ex7_22_h
+
+#include <string>
+#include <iostream>
+
+struct Person {
+    friend std::istream &read(std::istream &is, Person &person);
+    friend std::ostream &print(std::ostream &os, const Person &person);
+
+public:
+    Person() = default;
+    Person(const std::string sname, const std::string saddr):name(sname), address(saddr){}
+    Person(std::istream &is){read(is, *this);}
+
+    std::string getName() const { return name; }
+    std::string getAddress() const { return address; }
+private:
+    std::string name;
+    std::string address;
+};
+
+std::istream &read(std::istream &is, Person &person)
+{
+    is >> person.name >> person.address;
+    return is;
+}
+
+std::ostream &print(std::ostream &os, const Person &person)
+{
+    os << person.name << " " << person.address;
+    return os;
+}
+
+#endif