This document discusses object-oriented programming concepts including inheritance, polymorphism, and operator overloading. It provides examples of defining a Complex class with operator overloading, inheriting from a TableTennisPlayer class to create a RatedPlayer class, and using virtual functions and dynamic binding. Inheritance allows defining is-a relationships between classes. Polymorphism is demonstrated through virtual functions that can be redefined in derived classes.

1. Object-Oriented ProgrammingObject-Oriented Programming
(( 物件導向程式設計物件導向程式設計 ))
Lecturer: Liao Ping-Lun (Lecturer: Liao Ping-Lun ( 廖柄㷍廖柄㷍 ))
EMail:EMail: pinglunliao@gmail.compinglunliao@gmail.com

2. AgendaAgenda
Project Complex classProject Complex class
Project TStack with PersonProject TStack with Person
Inheritance (Inheritance ( 繼承繼承 ))
Polymorphism (Polymorphism ( 多型多型 ))

3. Overloaded Operators (Overloaded Operators ( 運算子重載運算子重載 ))
operator[] (subscript operator)operator[] (subscript operator)
char city[40] = "Taipei";char city[40] = "Taipei";
cout << city[1] << endl; // display 'a'cout << city[1] << endl; // display 'a'
String opera("The Duck");String opera("The Duck");
char& String::operator[](int)char& String::operator[](int)
{ return str[i]; } // opera[0] = 'T';{ return str[i]; } // opera[0] = 'T';
const char& String::operator[](int i) constconst char& String::operator[](int i) const
{ return str[i]; } // cout << opera[4];{ return str[i]; } // cout << opera[4];
// char ch = opera[3];// char ch = opera[3];

4. Overloaded Operators (Overloaded Operators ( 運算子重載運算子重載 ))
operator= (assignment operator)operator= (assignment operator)
Person me;Person me;
Person him = me; // not an assignmentPerson him = me; // not an assignment
him = me; // assignmenthim = me; // assignment
為什麼是為什麼是 return by reference?return by reference?
因為修改的是自己因為修改的是自己

5. Overloaded Operators (Overloaded Operators ( 運算子重載運算子重載 ))
重載重載 MyStackMyStack
operator=operator=
operator[]operator[]

6. Project Complex ClassProject Complex Class
Default ConstructorDefault Constructor
With default valueWith default value
Copy ConstructorCopy Constructor
Operator overloadingOperator overloading
operator+operator+
operator-operator-
operator*operator*
operator<<operator<<
operator>>operator>>
示範示範
operator+operator+

7. Project Complex ClassProject Complex Class
SolutionSolution

8. Pointer and objectPointer and object
String glamour;String glamour;
String *first = &glamour;String *first = &glamour; // assign object address// assign object address
String *gleep = new String;String *gleep = new String; // default constructor// default constructor
// invoke String(const char*) constructor// invoke String(const char*) constructor
String *glop = new String("me me me");String *glop = new String("me me me");
// invoke String(const String&) constructor// invoke String(const String&) constructor
String *favorite = new String(glamour);String *favorite = new String(glamour);
if(glamour < *first)if(glamour < *first) // compare object value// compare object value

9. Implicit and explicit type conversionImplicit and explicit type conversion
class Stringclass String
{{
//...//...
explicit String( const char* pstr ); // str = String("ABC");explicit String( const char* pstr ); // str = String("ABC");
operator char*();operator char*();
};};
String str;String str;
str = "TEST"; //Error: cannot convert "TEST" to String impstr = "TEST"; //Error: cannot convert "TEST" to String imp
licitlylicitly
char *pstr = str; // char *pstr = (char*)str;char *pstr = str; // char *pstr = (char*)str;

10. InheritanceInheritance
Is-a relationshipIs-a relationship
Public inheritancePublic inheritance
Initializer list in default constructorInitializer list in default constructor
Virtual member functionVirtual member function
Static binding and dynamic bindingStatic binding and dynamic binding
Abstract base classAbstract base class
Pure virtual functionPure virtual function
Public interfacePublic interface

11. Is-a & has-a relationshipsIs-a & has-a relationships
直線、矩形是圖形，但畫布上有好多圖形！直線、矩形是圖形，但畫布上有好多圖形！

12. Inheriting classInheriting class
Base classBase class
Derived classDerived class

13. Using Derived classUsing Derived class
跟在使用一般類別一樣的語法。跟在使用一般類別一樣的語法。

14. InheritanceInheritance

15. Inheritance classInheritance class
class RatedPlayerclass RatedPlayer: public: public TableTennisPlayerTableTennisPlayer
{{
private:private:
int rating;int rating;
public:public:
......
};};

16. Base and Derived Class ObjectBase and Derived Class Object

17. Access specify without inheritanceAccess specify without inheritance

18. Initilizer ListInitilizer List
Derived classDerived class 設定設定 Base classBase class 的的 privateprivate
member variablesmember variables 時時
RatedPlayer::RatedPlayer(unsigned int r, const charRatedPlayer::RatedPlayer(unsigned int r, const char
* fn, const char * ln, bool ht) : TableTennisPlayer* fn, const char * ln, bool ht) : TableTennisPlayer
(fn, ln, ht)(fn, ln, ht)
{{
rating = r;rating = r;
}}
RatedPlayer rplayer1(1140, "Mallory", "Duck", true)RatedPlayer rplayer1(1140, "Mallory", "Duck", true)
;;

19. Initilizer ListInitilizer List
RatedPlayer::RatedPlayer(unsigned int r, const charRatedPlayer::RatedPlayer(unsigned int r, const char
* fn, const char * ln, bool ht) : TableTennisPlayer* fn, const char * ln, bool ht) : TableTennisPlayer
(fn, ln, ht), rating(r)(fn, ln, ht), rating(r)
{}{}
RatedPlayer rplayer1(1140, "Mallory", "Duck", true)RatedPlayer rplayer1(1140, "Mallory", "Duck", true)
;;

20. Default constructor in derived classDefault constructor in derived class
Completely constructors in base classCompletely constructors in base class
Using initializer list to build up defaultUsing initializer list to build up default
constructor in derived classconstructor in derived class
Data members in initialization in derived clData members in initialization in derived cl
assass

21. Access specify with inheritanceAccess specify with inheritance

22. Special relationship between base and derived classSpecial relationship between base and derived class
Using base class methodUsing base class method
Upward castingUpward casting
Downward casting is not allowedDownward casting is not allowed

23. Using base class methodUsing base class method
RatedPlayer rplayer1(1140, "Mallory", "Duck", true);RatedPlayer rplayer1(1140, "Mallory", "Duck", true);
rplayer1.Name();rplayer1.Name();// derived object uses base method// derived object uses base method

24. Upward castingUpward casting
RatedPlayer rplayer1(1140, "Mallory", "Duck", true);RatedPlayer rplayer1(1140, "Mallory", "Duck", true);
TableTennisPlayer &rt = rplayer;TableTennisPlayer &rt = rplayer;
TAbleTennisPlayer *pt = &rplayer;TAbleTennisPlayer *pt = &rplayer;
rt.Name();rt.Name(); // invoke Name() with reference// invoke Name() with reference
pt->Name();pt->Name(); // invoke Name() with pointer// invoke Name() with pointer

25. Downward casting is not allowedDownward casting is not allowed
TableTennisPlayer player("Tara", "Boomdea", false)TableTennisPlayer player("Tara", "Boomdea", false)
;;
RatedPlayer &rrp = player;RatedPlayer &rrp = player; // not allowed// not allowed
RatedPlayer *prp = &player;RatedPlayer *prp = &player; // not allowed// not allowed

26. Implicit upward castingImplicit upward casting
void method(void method(const Base_class &bcconst Base_class &bc););
void Show(const TableTennisPlayer &rt)void Show(const TableTennisPlayer &rt)
{{
cout << "Name: ";cout << "Name: ";
rt.Name();rt.Name();
cout << "nTable: ";cout << "nTable: ";
if(rt.HasTable()) cout << "yesn";if(rt.HasTable()) cout << "yesn";
else cout << "non";else cout << "non";
}}
TableTennisPlayer player1("Tara", "Boomdea", false);TableTennisPlayer player1("Tara", "Boomdea", false);
RatedPlayer rplayer1(1140, "Mallory", "Duck", true);RatedPlayer rplayer1(1140, "Mallory", "Duck", true);
Show(player1);Show(player1);
Show(rplayer1);Show(rplayer1);

27. Implicit copy constructorImplicit copy constructor
RatedPlayer sams(1100, "Sams", "Lups", true);RatedPlayer sams(1100, "Sams", "Lups", true);
// invoke implicit copy constructor and up-casting, TableTenn// invoke implicit copy constructor and up-casting, TableTenn
isPlayer(const TableTennisPlayer&);isPlayer(const TableTennisPlayer&);
TableTennisPlayer fakeSams1(sams);TableTennisPlayer fakeSams1(sams);
TableTennisPlayer fakeSams2 = sams;TableTennisPlayer fakeSams2 = sams;
TableTennisPlayer fakeSams3;TableTennisPlayer fakeSams3;
fakeSams3 = sams;fakeSams3 = sams; // assignment op and up-casting// assignment op and up-casting

28. Inheritance modelInheritance model
PublicPublic
Is-a relationshipIs-a relationship
Illegal relationshipsIllegal relationships
Is-like-a, has-a, is-implemented-as, uses-aIs-like-a, has-a, is-implemented-as, uses-a
PrivatePrivate
ProtectedProtected

29. BindingBinding
Static binding (early binding)Static binding (early binding) during compiliduring compili
ngng
Dynamic binding (late binding)Dynamic binding (late binding) during execduring exec
utionution

30. Type compatibility of pointer and referenceType compatibility of pointer and reference
double x = 3.5;double x = 3.5;
int *pi = &x;int *pi = &x; // mismatch pointer types// mismatch pointer types
long &r = x;long &r = x; // mismatch reference type// mismatch reference type
DerivedClass test;DerivedClass test;
BaseClass *pd = &test; // okBaseClass *pd = &test; // ok
BaseClass &rd = test; // okBaseClass &rd = test; // ok

31. Upward & downward castingUpward & downward casting
class Singer: public Employeeclass Singer: public Employee
{{
public:public:
void range();void range();
};};
class Employeeclass Employee
{{
private:private:
char name[40];char name[40];
public:public:
void show_name();void show_name();
};};
Employee veep;Employee veep;
Singer trala;Singer trala;
Employee *pe = &trala;Employee *pe = &trala; // upward casting// upward casting
Singer *ps = (Singer*)&veep;Singer *ps = (Singer*)&veep; // downward casting// downward casting
pe->show_name();pe->show_name(); // ok// ok
pe->range();pe->range(); // compile error: range() is not a member of Employee// compile error: range() is not a member of Employee
ps->range();ps->range(); // Run time error// Run time error

32. Upward & downward castingUpward & downward casting
Why ?Why ?
downward casting: run time error.downward casting: run time error.
upward casting: compile error.upward casting: compile error.

33. Virtual member function & dynamic bindingVirtual member function & dynamic binding
Virtual function uses dynamic binding, whereas,Virtual function uses dynamic binding, whereas,
non-virtual function employs static bindingnon-virtual function employs static binding
Derived_class dc;Derived_class dc; // derived class// derived class
Base_class *bcp;Base_class *bcp; // base class// base class
bcp = &dc;bcp = &dc; // Base_class pointer to Derived_class object// Base_class pointer to Derived_class object
bcp->Function();bcp->Function(); // which version?// which version?

34. Virtual member function & dynamic bindingVirtual member function & dynamic binding
ExampleExample
Brass Porky("Porcelot Pigg", 381299, 4000.00);Brass Porky("Porcelot Pigg", 381299, 4000.00);
Brass *bp; // base classBrass *bp; // base class
bp = &Porky;bp = &Porky;
bp->ViewAcct(); // which version?bp->ViewAcct(); // which version?

35. Virtual or non-virtual?Virtual or non-virtual?
Virtual functionVirtual function
Base class member functionBase class member function isis allowedallowed to be rto be r
edefinededefined in derived classin derived class
Non-virtual functionNon-virtual function
Base class member functionBase class member function isis not allowednot allowed toto
bebe redefined in derived classredefined in derived class

36. How virtual function work?How virtual function work?
ExampleExample
Instrument4.cppInstrument4.cpp

37. How virtual function work?How virtual function work?
*Virtual function table (vtbl)*Virtual function table (vtbl)
Single ObjectSingle Object

38. How virtual function work?How virtual function work?
*Virtual function table (vtbl)*Virtual function table (vtbl)
Multiple ObjectMultiple Object

39. Price for using virtual functionPrice for using virtual function
Extra vtbl space using for every object creExtra vtbl space using for every object cre
ationation
Compiler will create an array to store virtuaCompiler will create an array to store virtua
l function address in every classl function address in every class
Extra time using in finding the function addExtra time using in finding the function add
ressress

40. Rules for virtual functionRules for virtual function
Constructor cannot be a virtual functionConstructor cannot be a virtual function
Destructor usually be a virtual functionDestructor usually be a virtual function
Friend function cannot be a virtual functionFriend function cannot be a virtual function
Static function cannot be a virtual functionStatic function cannot be a virtual function
Function signature consistence in a redefinFunction signature consistence in a redefin
ed functioned function
If virtual functions are overloaded in base cIf virtual functions are overloaded in base c
lass, then redefined all the functions in derilass, then redefined all the functions in deri
ved classved class

41. Accessibility for protectedAccessibility for protected

42. Member functions in classMember functions in class

43. PolymorphismPolymorphism
ExampleExample
RoughDrawRoughDraw
PracticePractice
加上加上 RRectRRect 和和 EllipseEllipse 兩個類別。兩個類別。

44. ReferencesReferences
Thinking in C++ (Free E-Book)Thinking in C++ (Free E-Book)
Beginning C++: The Complete LanguageBeginning C++: The Complete Language
(( 中譯：中譯： C++C++ 教學範本教學範本 ))
物件導向程式設計物件導向程式設計 hh
ttp://vr.me.ncku.edu.tw/courses/index-oop.htmttp://vr.me.ncku.edu.tw/courses/index-oop.htm
良葛格學習筆記良葛格學習筆記 httphttp
://caterpillar.onlyfun.net/Gossip/index.html://caterpillar.onlyfun.net/Gossip/index.html