Object-Oriented Programming With ANSI-C (pdf)

viii __________________________________________________________________________ Contents
4.8 Summary . . . . . . . . . . . . . . . . . . . . . . 40
4.9 Is It or Has It? — Inheritance vs. Aggregates . . . . . . . . 42
4.10 Multiple Inheritance . . . . . . . . . . . . . . . . . . 42
4.11 Exercises . . . . . . . . . . . . . . . . . . . . . . 43
5 Programming Savvy — Symbol Table . . . . . . . . . . . . . 45
5.1 Scanning Identifiers . . . . . . . . . . . . . . . . . . 45
5.2 Using Variables . . . . . . . . . . . . . . . . . . . . 45
5.3 The Screener — Name . . . . . . . . . . . . . . . . . 47
5.4 Superclass Implementation — Name . . . . . . . . . . . . 48
5.5 Subclass Implementation — Var . . . . . . . . . . . . . . 50
5.6 Assignment . . . . . . . . . . . . . . . . . . . . . 51
5.7 Another Subclass — Constants . . . . . . . . . . . . . . 52
5.8 Mathematical Functions — Math . . . . . . . . . . . . . 52
5.9 Summary . . . . . . . . . . . . . . . . . . . . . . 55
5.10 Exercises . . . . . . . . . . . . . . . . . . . . . . 55
6 Class Hierarchy — Maintainability . . . . . . . . . . . . . . . 57
6.1 Requirements . . . . . . . . . . . . . . . . . . . . . 57
6.2 Metaclasses . . . . . . . . . . . . . . . . . . . . . 58
6.3 Roots — Object and Class . . . . . . . . . . . . . . . . 59
6.4 Subclassing — Any . . . . . . . . . . . . . . . . . . 60
6.5 Implementation — Object . . . . . . . . . . . . . . . . 62
6.6 Implementation — Class . . . . . . . . . . . . . . . . 63
6.7 Initialization . . . . . . . . . . . . . . . . . . . . . 65
6.8 Selectors . . . . . . . . . . . . . . . . . . . . . . 65
6.9 Superclass Selectors . . . . . . . . . . . . . . . . . . 66
6.10 A New Metaclass — PointClass . . . . . . . . . . . . . . 68
6.11 Summary . . . . . . . . . . . . . . . . . . . . . . 70
7 The ooc Preprocessor — Enforcing a Coding Standard . . . . . . 73
7.1 Point Revisited . . . . . . . . . . . . . . . . . . . . 73
7.2 Design . . . . . . . . . . . . . . . . . . . . . . . 78
7.3 Preprocessing . . . . . . . . . . . . . . . . . . . . 79
7.4 Implementation Strategy . . . . . . . . . . . . . . . . 80
7.5 Object Revisited . . . . . . . . . . . . . . . . . . . . 82
7.6 Discussion . . . . . . . . . . . . . . . . . . . . . . 84
7.7 An Example — List, Queue, and Stack . . . . . . . . . . . 85
7.8 Exercises . . . . . . . . . . . . . . . . . . . . . . 89
8 Dynamic Type Checking — Defensive Programming . . . . . . . 91
8.1 Technique . . . . . . . . . . . . . . . . . . . . . . 91
8.2 An Example — list . . . . . . . . . . . . . . . . . . . 92
8.3 Implementation . . . . . . . . . . . . . . . . . . . . 94
8.4 Coding Standard . . . . . . . . . . . . . . . . . . . . 94
8.5 Avoiding Recursion . . . . . . . . . . . . . . . . . . 98
8.6 Summary . . . . . . . . . . . . . . . . . . . . . . 100
8.7 Exercises . . . . . . . . . . . . . . . . . . . . . . 101