From 58b8a67d551faca7c4f425b4c47b171f6b2f0cba Mon Sep 17 00:00:00 2001 From: Jidong Xiao Date: Mon, 14 Apr 2025 18:56:18 -0400 Subject: [PATCH] removing outdated content --- lectures/26_inheritance_II/README.md | 191 +-------------------------- 1 file changed, 6 insertions(+), 185 deletions(-) diff --git a/lectures/26_inheritance_II/README.md b/lectures/26_inheritance_II/README.md index 7c225ba..83837eb 100644 --- a/lectures/26_inheritance_II/README.md +++ b/lectures/26_inheritance_II/README.md @@ -1,185 +1,6 @@ # Lecture 26 --- C++ Inheritance and Polymorphism -## Today’s Lecture - -- 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 -// 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 stack : private std::list { -public: - stack() {} - stack(stack const& other) : std::list(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::size(); } - bool empty() { return std::list::empty(); } -}; -``` - -- Private inheritance hides the std::list<T> member functions from the outside world. However, these member functions are still available to the member functions of the stack<T> 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 +## 26.1 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::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)?