removing outdated content

lectures/26_inheritance_II/README.md

@@ -1,185 +1,6 @@
 # Lecture 26 ---  C++ Inheritance and Polymorphism
 
-## Today’s Lecture
+## 26.1 Multiple Inheritance
-
-- Inheritance is a relationship among classes. Examples: bank accounts, polygons, stack & list
-- Basic mechanisms of inheritance
-- Types of inheritance
-- Is-A, Has-A, As-A relationships among classes.
-- Polymorphism
-
-## 26.1 Motivating Example: Bank Accounts
-
-- Consider different types of bank accounts:  
-  – Savings accounts  
-  – Checking accounts  
-  – Time withdrawal accounts (like savings accounts, except that only the interest can be withdrawn)
-- If you were designing C++ classes to represent each of these, what member functions might be repeated among the different classes? What member functions would be unique to a given class?
-- To avoid repeating common member functions and member variables, we will create a class hierarchy, where the common members are placed in a base class and specialized members are placed in derived classes.
-
-## 26.2 Accounts Hierarchy
-
-- Account is the base class of the hierarchy.
-- SavingsAccount is a derived class from Account. SavingsAccount has inherited member variables & functions
-and ordinarily-defined member variables & functions.
-- The member variable balance in base class Account is protected, which means:  
-  – balance is NOT publicly accessible outside the class, but it is accessible in the derived classes.  
-  – if balance was declared as private, then SavingsAccount member functions could not access it.
-- When using objects of type SavingsAccount, the inherited and derived members are treated exactly the same
-and are not distinguishable.
-- CheckingAccount is also a derived class from base class Account.
-- TimeAccount is derived from SavingsAccount. SavingsAccount is its base class and Account is its indirect base class
-
-## 26.3 Exercise: Draw the Accounts Class Hierarchy
-
-```cpp
-#include <iostream>
-// Note we've inlined all the functions (even though some are > 1 line of code)
-class Account {
-public:
-	Account(double bal = 0.0) : balance(bal) {}
-	void deposit(double amt) { balance += amt; }
-	double get_balance() const { return balance; }
-protected:
-	double balance; // account balance
-};
-class SavingsAccount : public Account {
-public:
-	SavingsAccount(double bal = 0.0, double pct = 5.0) : Account(bal), rate(pct/100.0) {}
-	double compound() { // computes and deposits interest
-		double interest = balance * rate;
-		balance += interest;
-		return interest;
-	}
-	double withdraw(double amt) { // if overdraft ==> return 0, else return amount
-		if (amt > balance) {
-			return 0.0;
-		}else {
-			balance -= amt;
-			return amt;
-		}
-	}
-protected:
-	double rate; // periodic interest rate
-};
-class CheckingAccount : public Account {
-public:
-	CheckingAccount(double bal = 0.0, double lim = 500.0, double chg = 0.5) : Account(bal), limit(lim), charge(chg) {}
-	double cash_check(double amt) {
-		assert (amt > 0);
-		if (balance < limit && (amt + charge <= balance)) {
-			balance -= amt + charge;
-			return amt + charge;
-		} else if (balance >= limit && amt <= balance) {
-			balance -= amt;
-			return amt;
-		} else {
-			return 0.0;
-		}
-	}
-protected:
-	double limit; // lower limit for free checking
-	double charge; // per check charge
-};
-class TimeAccount : public SavingsAccount {
-public:
-	TimeAccount(double bal = 0.0, double pct = 5.0) : SavingsAccount(bal, pct), funds_avail(0.0) {}
-	// redefines 2 member functions from SavingsAccount
-	double compound() {
-		double interest = SavingsAccount::compound();
-		funds_avail += interest;
-		return interest;
-	}
-	double withdraw(double amt) {
-		if (amt <= funds_avail) {
-			funds_avail -= amt;
-			balance -= amt;
-			return amt;
-		} else {
-			return 0.0;
-		}
-	}
-	double get_avail() const { return funds_avail; };
-protected:
-	double funds_avail; // amount available for withdrawal
-};
-```
-
-```cpp
-Account a(100); //<---one balance member, not related to c1
-CheckingAccount c1(100, 366, 0.4); //c1 has it's own CheckingAccount + Account objects <---one balance member
-```
-
-## 26.4 Constructors and Destructors
-
-- Constructors of a derived class call the base class constructor immediately, before doing ANYTHING else.
-The only thing you can control is which constructor is called and what the arguments will be. Thus when
-a TimeAccount is created 3 constructors are called: the Account constructor, then the SavingsAccount
-constructor, and then finally the TimeAccount constructor.
-- The reverse is true for destructors: derived class destructors do their jobs first and then base class destructors
-are called at the end, automatically. Note: destructors for classes which have derived classes must be marked
-virtual for this chain of calls to happen.
-
-## 26.5 Overriding Member Functions in Derived Classes
-
-- A derived class can redefine member functions in the base class. The function prototype must be identical, not even the use of const can be different.
-- For example, see TimeAccount::compound and TimeAccount::withdraw.
-- Once a function is redefined it is not possible to call the base class function, unless it is explicitly called. As an example, the call to SavingsAccount::compound inside of TimeAccount::compound.
-
-## 26.6 Public, Private and Protected Inheritance
-
-- Notice the line 
-```cpp
-class Savings_Account : public Account {
-```
-  This specifies that the member functions and variables from Account do not change their public, protected or private status in SavingsAccount. This is called public inheritance.
-- protected and private inheritance are other options:
-
-  – With protected inheritance, public members becomes protected and other members are unchanged
-
-  – With private inheritance, all members become private.
-
-## 26.7 Stack Inheriting from List
-
-- For another example of inheritance, let’s re-implement the stack class as a derived class of std::list:
-
-```cpp
-template <class T>
-class stack : private std::list<T> {
-public:
-	stack() {}
-	stack(stack<T> const& other) : std::list<T>(other) {}
-	~stack() {}
-	void push(T const& value) { this->push_back(value); }
-	void pop() { this->pop_back(); }
-	T const& top() const { return this->back(); }
-	int size() { return std::list<T>::size(); }
-	bool empty() { return std::list<T>::empty(); }
-};
-```
-
-- Private inheritance hides the std::list&lt;T&gt; member functions from the outside world. However, these member functions are still available to the member functions of the stack&lt;T&gt; class.
-- Note: no member variables are defined — the only member variables needed are in the list class.
-- When the stack member function uses the same name as the base class (list) member function, the name of the base class followed by :: must be provided to indicate that the base class member function is to be used.
-- The copy constructor just uses the copy constructor of the base class, without any special designation because the stack object is a list object as well.
-
-## 26.8 Is-A, Has-A, As-A Relationships Among Classes
-
-- When trying to determine the relationship between (hypothetical) classes C1 and C2, try to think of a logical relationship between them that can be written:  
-  – C1 is a C2,  
-  – C1 has a C2, or  
-  – C1 is implemented as a C2
-- If writing “C1 is-a C2” is best, for example: “a savings account is an account”, then C1 should be a derived class (a subclass) of C2.
-- If writing “C1 has-a C2” is best, for example: “a cylinder has a circle as its base”, then class C1 should have a member variable of type C2.
-- In the case of “C1 is implemented as-a C2”, for example: “the stack is implemented as a list”, then C1 should be derived from C2, but with private inheritance. This is by far the least common case!
-
-## 26.9 Exercise: 2D Geometric Primitives
-
-Create a class hierarchy of geometric objects, such as: triangle, isosceles triangle, right triangle, quadrilateral, square,
-rhombus, kite, trapezoid, circle, ellipse, etc. How should this hierarchy be arranged? What member variables and
-member functions should be in each class?
-
-## 26.10 Multiple Inheritance
 
 - When sketching a class hierarchy for geometric objects, you may have wanted to specify relationships that were more complex... in particular some objects may wish to inherit from more than one base class.
 - This is called multiple inheritance and can make many implementation details significantly more hairy. Different programming languages offer different variations of multiple inheritance.
@@ -191,7 +12,7 @@ member functions should be in each class?
 
   ![alt text](Note_multipleInheritance.png "MultipleInheritance_note")
 
-## 26.11 Introduction to Polymorphism
+## 26.2 Introduction to Polymorphism
 
 - Let’s consider a small class hierarchy version of polygonal objects:
 
@@ -233,7 +54,7 @@ they must be redefined in a derived class.
   – Objects of abstract types may not be created — only pointers to these objects may be created.  
 - Functions that are specific to a particular object type are declared in the derived class prototype.
 
-## 26.12 A Polymorphic List of Polygon Objects
+## 26.3 A Polymorphic List of Polygon Objects
 
 - Now instead of two separate lists of polygon objects, we can create one “polymorphic” list:
 
@@ -254,7 +75,7 @@ polygons.push_back(t_ptr);
 
 Note: We’ve used the same pointer variable (p_ptr) to point to objects of two different types.
 
-## 26.13 Accessing Objects Through a Polymorphic List of Pointers
+## 26.4 Accessing Objects Through a Polymorphic List of Pointers
 
 - Let’s sum the areas of all the polygons:
 
@@ -293,7 +114,7 @@ for (std::list<Polygon*>::iterator i = polygons.begin(); i!=polygons.end(); ++i)
 }
 ```
 
-## 26.14 Exercise
+## 26.5 Exercise
 
 What is the output of the following [program](exercise.cpp)?
 
@@ -334,6 +155,6 @@ int main() {
 }
 ```
 
-## 26.15 Exercise
+## 26.6 Exercise
 
 What is the output of the following [program](virtual.cpp)?