Cover
Half Title
Title Page
Copyright Page
Contents
Preface
Acknowledgements
Detailed Book Outline
Section I: Stable Type Design
Chapter 1. Contractual Design and the Class Construct
1.1. Encapsulation
1.2. Explicit Design and Constraints
1.2.1. Class (Type) Functionality
1.2.2. Constructors
1.2.3. Accessors and Mutators
1.2.4. Utility and Public Methods
1.2.5. Destructors
1.3. Design as a Contract
1.3.1. Error Handling
1.3.2. Published Assumptions
1.3.3. Invariants
1.4. Programming by Contract Example
1.5. Contractual Expectations
1.6. OO Design Principles
1.7. Summary
1.8. Design Exercise
Conceptual Questions
Chapter 2. Ownership โ Abstracted but Tracked
2.1. The Abstraction of Memory
2.2. Heap Memory
2.3. Ownership of Heap Objects
2.3.1. Array Allocation
2.3.2. Design Intervention
2.3.3. Persistent Data
2.4. Class Design
2.5. Memory Reclamation
2.5.1. C++ Explicit Deallocation
2.5.2. Garbage Collection
2.5.3. Reference Counting
2.6. Design: Storage Versus Computation
2.7. OO Design Principles
2.7.1. Responsibility Driven Design Principle
2.8. Summary
2.9. Design Exercise
Conceptual Questions
Chapter 3. Data Integrity
3.1. Data Corruption
3.2. Copying
3.2.1. Shallow Versus Deep Copying
3.2.2. C++ Copying of Internal Heap Memory
3.3. Unseen Aliasing
3.3.1. C# Cloning to Avoid Aliasing
3.4. Move Semantics
3.5. Handle: C++ Smart Pointers
3.5.1. Unique_ptr
3.5.2. Shared_ptr
3.5.3. Weak_ptr
3.5.4. Usage
3.6. OO Design Principle
3.7. Summary
3.8. Design Exercises
Conceptual Questions
Section II : Strategic Type Coupling
Chapter 4. Composition
4.1. Object-Oriented Relationships
4.2. Containment (Holds-A)
4.3. Composition (Has-A)
4.3.1. Modification
4.3.2. Replacement
4.3.3. Postponed Instantiation
4.3.4. Echoing an Interface
4.4. Interfaces for Design Consistency
4.5. Wrappers and Delegates
4.6. Dependency Injection
4.6.1. Constructor Injection
4.6.2. Property Injection
4.6.3. Method Injection
4.6.4. Dependency Injection Costs and Benefits
4.7. Design Principles
4.8. Summary
4.9. Design Exercise
Conceptual Questions
Chapter 5. Inheritance
5.1. Automate Type Checking
5.2. Polymorphism
5.2.1. Overloading
5.2.2. Generics
5.2.3. Subtype Polymorphism
5.2.4. Function Inlining
5.2.5. Costs and Benefits of Polymorphism
5.3. Dynamic Binding
5.3.1. Whoami( ) Type Identification
5.3.2. Keywords for Dynamic Binding
5.4. Heterogeneous Collections
5.5. Virtual Function Table
5.6. Abstract Classes
5.7. Inheritance Designs
5.8. OO Design Principles
5.9. Summary
5.10. Design Exercises
Conceptual Questions
Chapter 6. Inheritance Versus Composition
6.1. Constrained Inheritance
6.1.1. When Only Composition Is Viable
6.1.2. When Inheritance Leaks Memory: C++ Destructors
6.1.3. Inconsistent Access: C++ Accessibility and Binding
6.2. Code Reuse
6.3. Class Design: Has-A or Is-A?
6.4. Inheritance with and Without Composition
6.5. Software Maintainability
6.6. OO Design Principle
6.7. Summary
6.8. Design Exercises
Conceptual Questions
Section III : Effective Type Reuse
Chapter 7. Design Longevity
7.1. Software Evolution
7.2. Disassembler Example
7.2.1. Virtual Function Table
7.3. Type Extraction
7.4. Problematic Type Extension
7.5. Multiple Inheritance and Its Simulation
7.5.1. Design Difficulties
7.5.2. Single Inheritance with Composition
7.5.3. Simulation Without Inheritance
7.6. Class Hierarchies Cross-Products
7.7. OO Design Principle
7.8. Summary
7.9. Design Exercises
Conceptual Questions
Chapter 8. Operator Overloading
8.1. Operators Represent Functions
8.2. Overloading Addition in C++
8.3. Client Expectations
8.4. Operator Overloading in C#
8.5. Operators Overloaded Only in C++
8.5.1. Indexing Support
8.5.2. I/O Via the Stream Operators
8.5.3. Type Conversion
8.5.4. Transparent Access
8.6. OO Design Principle
8.7. Summary
8.8. Design Exercise
Conceptual Questions
Appendix A: The Pointer Construct
A.1. Pointer Definition
A.2. Dereferencing Pointers
A.3. Inappropriate Use of Pointers
A.4. Transient Versus Persistent Memory
A.5. References
A.6. The This Pointer
A.7. Arrays
A.8. Summary
Appendix B: Design Exercises
B.1. Contractual Class Design
B.2. Ownership: C++ Class Memory Management
B.3. Copying
B.4. Composition
B.5. Inheritance
Appendix C: Comparative Design Exercises
C.1. Composition Versus Inheritance
C.2. Design Longevity
C.3. Operator Overloading
Glossary
Bibliography
Index