Add soultions to first half of exercises in chapter 15.

Author: Jaege

README.md

@@ -139,7 +139,6 @@ This repo is the solutions to exercises in book [_C++ Primer_ (5th Edition)](htt
 [41](ch14/14.41.md)|[42](ch14/14.42.cpp)|[43](ch14/14.43.cpp)|[44](ch14/14.44.cpp)|[45](ch14/14.45.cpp)|[46](ch14/14.46.md)|[47](ch14/14.47.md)|[48](ch14/14.48.md)|[49](ch14/14.49.md)|[50](ch14/14.50.cpp)|
 [51](ch14/14.51.cpp)|[52](ch14/14.52.cpp)|[53](ch14/14.53.cpp)
 
-<!---
 #### Chapter 15 [Object-Oriented Programming](ch15)
 
  1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
@@ -150,6 +149,7 @@ This repo is the solutions to exercises in book [_C++ Primer_ (5th Edition)](htt
 [31](ch15/15.31.cpp)|[32](ch15/15.32.cpp)|[33](ch15/15.33.cpp)|[34](ch15/15.34.cpp)|[35](ch15/15.35.cpp)|[36](ch15/15.36.cpp)|[37](ch15/15.37.cpp)|[38](ch15/15.38.cpp)|[39](ch15/15.39.cpp)|[40](ch15/15.40.cpp)|
 [41](ch15/15.41.cpp)|[42](ch15/15.42.cpp)
 
+<!---
 #### Chapter 16 [Templates and Generic Programming](ch16)
 
  1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10

ch15/15.1.md

@@ -0,0 +1 @@
+A virtual member is  a function that the base class expects its derived classes to override. When we call a virtual function through a pointer or reference to base class, the call will be dynamically bound to the virtual function of the dynamic type of the pointer or reference.

ch15/15.10.md

@@ -0,0 +1 @@
+`ifstream` is inherited from `istream`. Thus, we can use objects of type `ifstream` as if they were `istream` objects. The parameter of `read` function is a reference to base type `istream`, the automatic derived-to-base conversion applies when we pass a derived type `ifstream` to that function. Inside `read` function, we can use the `istream` subpart in the `ifstream` object through the reference.

ch15/15.11.cpp

@@ -0,0 +1,99 @@
+// based on ex15.7
+#include <string>
+#include <iostream>
+
+class Quote {
+public:
+  Quote() = default;
+  Quote(const std::string &book, double pri)
+      : bookNo(book), price(pri) { }
+
+  virtual ~Quote() = default;
+
+  std::string isbn() const { return bookNo; }
+  virtual double net_price(std::size_t n) const { return n * price; }
+
+  virtual std::ostream &debug(std::ostream &os) const {
+    os << "Quote::bookNo " << bookNo << " Quote::price " << price;
+    return os;
+  }
+
+protected:
+  double price = 0.0;
+
+private:
+  std::string bookNo;
+};
+
+class Bulk_quote : public Quote {
+public:
+  Bulk_quote() = default;
+  Bulk_quote(const std::string &book, double pri,
+             std::size_t qty, double disc)
+      : Quote(book, pri), min_qty(qty), discount(disc) { }
+
+  double net_price(std::size_t n) const override {
+    if (n >= min_qty)
+      return n * price * (1 - discount);
+    else
+      return n * price;
+  }
+
+  std::ostream &debug(std::ostream &os) const override {
+    Quote::debug(os) << " Bulk_quote::min_qty " << min_qty
+        << " Bulk_quote::discount " << discount;
+    return os;
+  }
+
+private:
+  std::size_t min_qty = 0;
+  double discount = 0.0;
+};
+
+class Limit_quote : public Quote {
+public:
+  Limit_quote() = default;
+  Limit_quote(const std::string &book, double pri,
+             std::size_t qty, double disc)
+      : Quote(book, pri), max_qty(qty), discount(disc) { }
+
+  double net_price(std::size_t n) const override {
+    if (n <= max_qty)
+      return n * price * (1 - discount);
+    else
+      return (n - max_qty) * price + max_qty * price * (1 - discount);
+  }
+
+  std::ostream &debug(std::ostream &os) const override {
+    Quote::debug(os) << " Limit_quote::max_qty " << max_qty
+        << " Limit_quote::discount " << discount;
+    return os;
+  }
+
+private:
+  std::size_t max_qty = 0;
+  double discount = 0.0;
+};
+
+double print_total(std::ostream &os, const Quote &item, size_t n) {
+  double ret = item.net_price(n);
+  os << "ISBN: " << item.isbn() << " # sold: " << n << " total due: " << ret
+     << std::endl;
+  return ret;
+}
+
+int main() {
+  Quote basic("abc", 5.5);
+  Bulk_quote bulk("abc", 5.5, 10, 0.2);
+  Limit_quote limit("abc", 5.5, 5, 0.2);
+
+  print_total(std::cout, basic, 20);
+  print_total(std::cout, bulk, 20);
+  print_total(std::cout, limit, 20);
+
+  basic.debug(std::cout) << std::endl;
+  bulk.debug(std::cout) << std::endl;
+  limit.debug(std::cout) << std::endl;
+
+  return 0;
+}

ch15/15.12.md

@@ -0,0 +1,64 @@
+Both `override` and `final` can appear only in declaration in a virtual function. And both key words can be used in the same function declaration, but whether it is useful to use them both depends on situations.
+
+Take the following code as an example:
+
+    #include <iostream>
+    using std::cout; using std::endl;
+
+    struct B {
+      virtual void f1() { cout << "B::f1() "; }
+      virtual void f2() { cout << "B::f2() "; }
+      virtual void f3() { cout << "B::f3() "; }
+      virtual void f6() final { cout << "B::f6() "; }
+      void f7() { cout << "B::f7() "; }
+      void f8() { cout << "B::f8() "; }
+      void f9() { cout << "B::f9() "; }
+    };
+
+    struct D : B {
+      void f1() override { cout << "D::f1() "; }
+      void f2() final { cout << "D::f2() "; }
+      void f3() override final { cout << "D::f3() "; }  // need not have override
+      // should have override, otherwise add new virtual function
+      virtual void f4() final { cout << "D::f4() "; }
+      //virtual void f5() override final;  // Error, no virtual function in base class
+      //void f6(); // Error, override a final virtual function
+      void f7() { cout << "D::f7() "; }
+      virtual void f8() { cout << "D::f8() "; }
+      //void f9() override;  // Error, override a nonvirtual function 
+    };
+
+    int main() {
+      B b; D d;
+      B *bp = &b, *bd = &d; D *dp = &d;
+      bp->f1(); bp->f2(); bp->f3(); bp->f6(); bp->f7(); bp->f8(); bp->f9(); cout << endl;
+      bd->f1(); bd->f2(); bd->f3(); bd->f6(); bd->f7(); bd->f8(); bd->f9(); cout << endl;
+      dp->f1(); dp->f2(); dp->f3(); dp->f6(); dp->f7(); dp->f8(); dp->f9(); cout << endl;
+      return 0;
+    }
+
+The output is
+
+    B::f1() B::f2() B::f3() B::f6() B::f7() B::f8() B::f9()
+    D::f1() D::f2() D::f3() B::f6() B::f7() B::f8() B::f9()
+    D::f1() D::f2() D::f3() B::f6() D::f7() D::f8() B::f9()
+
+1. Compare `f1()` and `f6()`. We know that `override` and `final` is indepent sematically.
+
+  - `override` means the function is overriding a virtual function in its base class. See `f1()` and `f3()`.
+  - `final` means the function cannot be overrided by its derived class. (But the function itself need not override a base class virtual function.) See `f6()` and `f4()`.
+
+2. Compare `f2()` and `f3()`. We know that if a member function is declared without `virtual` and with `final`, it means that it already override a virtual function in base class. In this case, the key word `override` is redundant.
+
+3. Compare `f4()` and `f5()`. We know that if a member function is declared with `virtual`and if it is not the *first* virtual function in inheritance hierarchy, then we should use `override` to specify the override relationship. Otherwise, we may accidentally add new virtual function in derived class.
+
+4. Compare `f1()` and `f7()`. We know that any member function, not just virtual ones, can be overridden in derived class. What `virtual` specifies is *polymorphism*, which means the decision as to which function to run is delayed until run time instead of compile time. (This should be avoid in practice.)
+
+5. Compare `f7()` and `f8()`. We know that we can even override a base class function and make it a new virtual one. (Which means any member function `f8()` of class derived from `D` will be virtual.) (This should be avoid in practice too.)
+
+6. Compare `f7()` and `f9()`. We know that `override` can help us find the error when we want to override a virtual function in derived class while forgot to add key word `virtual` in base class.
+
+**In conclusion**, the best practice in my own view is:
+
+  - *only* use `virtual` in declaration of the *first* virtual function in base class;
+  - always use `override` to specify override virtual function in derived class, unless `final` is also specified.

ch15/15.13.md

@@ -0,0 +1,3 @@
+The derived virtual function `print` try to call the base version in its function body, but without the scope operator, the call will be resolved at run time as a call to the derived version itself, resulting in an infinite recursion.
+
+To fix this problem, we need to prefix the scope operator to the call like `base::print(os);`.

ch15/15.14.cpp

@@ -0,0 +1,38 @@
+#include <string>
+#include <iostream>
+using std::string;
+using std::ostream;
+
+class base {
+public:
+  string name() { return basename; }
+  virtual void print(ostream &os) { os << basename; }
+private:
+  string basename;
+};
+
+class derived : public base {
+public:
+  void print(ostream &os) { base::print(os); os << " " << i; }
+private:
+  int i = 0;
+};
+
+int main() {
+  base bobj; base *bp1 = &bobj; base &br1 = bobj;
+  derived dobj; base *bp2 = &dobj; base &br2 = dobj;
+  // (a) base::print();
+  bobj.print(std::cout);
+  // (b) derived::print();
+  dobj.print(std::cout);
+  // (c) base::name();
+  bp1->name();
+  // (d) base::name();
+  bp2->name();
+  // (e) base::print();
+  br1.print(std::cout);
+  // (f) derived::print();
+  br2.print(std::cout);
+
+  return 0;
+}

ch15/15.15.cpp

@@ -0,0 +1,97 @@
+// based on ex15.11
+#include <string>
+#include <iostream>
+
+class Quote {
+public:
+  Quote() = default;
+  Quote(const std::string &book, double pri)
+      : bookNo(book), price(pri) { }
+
+  virtual ~Quote() = default;
+
+  std::string isbn() const { return bookNo; }
+  virtual double net_price(std::size_t n) const { return n * price; }
+
+  virtual std::ostream &debug(std::ostream &os) const {
+    os << "Quote::bookNo " << bookNo << " Quote::price " << price;
+    return os;
+  }
+
+protected:
+  double price = 0.0;
+
+private:
+  std::string bookNo;
+};
+
+class Disc_quote : public Quote {
+public:
+  Disc_quote() = default;
+  Disc_quote(const std::string &book, double pri,
+             std::size_t qty, double disc)
+      : Quote(book, pri), quantity(qty), discount(disc) { }
+
+  double net_price(std::size_t n) const = 0;
+
+  std::ostream &debug(std::ostream &os) const override {
+    Quote::debug(os) << " Disc_quote::quantity " << quantity
+        << " Disc_quote::discount " << discount;
+    return os;
+  }
+
+protected:
+  std::size_t quantity = 0;
+  double discount = 0.0;
+};
+
+class Bulk_quote : public Disc_quote {
+public:
+  Bulk_quote() = default;
+  Bulk_quote(const std::string &book, double pri, std::size_t qty, double disc)
+      : Disc_quote(book, pri, qty, disc) { }
+
+  double net_price(std::size_t n) const override {
+    if (n >= quantity)
+      return n * price * (1 - discount);
+    else
+      return n * price;
+  }
+};
+
+class Limit_quote : public Disc_quote {
+public:
+  Limit_quote() = default;
+  Limit_quote(const std::string &book, double pri, std::size_t qty, double disc)
+      : Disc_quote(book, pri, qty, disc) { }
+
+  double net_price(std::size_t n) const override {
+    if (n <= quantity)
+      return n * price * (1 - discount);
+    else
+      return (n - quantity) * price + quantity * price * (1 - discount);
+  }
+};
+
+double print_total(std::ostream &os, const Quote &item, size_t n) {
+  double ret = item.net_price(n);
+  os << "ISBN: " << item.isbn() << " # sold: " << n << " total due: " << ret
+     << std::endl;
+  return ret;
+}
+
+int main() {
+  Quote basic("abc", 5.5);
+  Bulk_quote bulk("abc", 5.5, 10, 0.2);
+  Limit_quote limit("abc", 5.5, 5, 0.2);
+
+  print_total(std::cout, basic, 20);
+  print_total(std::cout, bulk, 20);
+  print_total(std::cout, limit, 20);
+
+  basic.debug(std::cout) << std::endl;
+  bulk.debug(std::cout) << std::endl;
+  limit.debug(std::cout) << std::endl;
+
+  return 0;
+}

ch15/15.16.md

@@ -0,0 +1 @@
+See [ex15.15](15.15.cpp).