Object-Oriented Design Choices

Adair Dingle, PhD, is a professor of computer science at Seattle University, Washington, USA whose previous text, Software Essentials: Design and Construction, received the 2015 Alpha Sigma Nu Book Award. Teaching and research interests focus on algorithms and software design including efficient memory management, patterns, refactoring and tools for software development and education.

"The introduction of object-oriented programming was a pivotal moment in software engineering, leading to a new way of creating systems by modelling their constituents independently and linking them through shared interfaces. Object orientation allows for the creation of more complex systems, better focus on a small subset of components at any given time, and a greater level of component independence; it even facilitates the creation of software product lines. Designing a system using object orientation requires the mastery of several interdependent concepts, such as abstraction, inheritance, composition, and polymorphism. Dingle (Seattle Univ.) provides a cohesive framework for learning object-oriented design from a practical point of view. Concepts are introduced hierarchically, starting from the idea of encapsulation and design as a contract and drilling down to specifics such as virtual function tables and abstract classes. This approach results in an incremental experience of learning object-oriented design that is rarely found in computer science courses, but that is essential for software engineers who wish to harness the power of object-oriented programming languages in practice. Although no book can fully replace hands-on bench experience, this compact guide can ensure that one's practical efforts will be optimally targeted.--L. Benedicenti, University of New BrunswickReview in April 2022 Issue of CHOICE

• PrefaceDetailed Book OutlineSection I: Stable Type DesigContractual Design and the Class ConstructEncapsulation Explicit Design and ConstraintsClass (Type) FunctionalityConstructorsAccessors and MutatorsUtility and Public MethodsDestructorsDesign as a ContractError HandlingPublished AssumptionsInvariantsProgramming by Contract ExampleContractual ExpectationsOO Design PrincipleSummaryDesign ExercisesOwnership – Abstracted but TrackedThe Abstraction of Memory Heap MemoryOwnership of Heap ObjectsArray AllocationDesign InterventionPersistent DataClass Design Memory ReclamationC++ Explicit DeallocationGarbage CollectionReference CountingDesign: Storage vs Computation OO Design PrincipleSummaryDesign ExerciseData IntegrityData CorruptionCopyingShallow versus Deep CopyingC++ Copying of Internal Heap MemoryUnseen AliasingC# Cloning to Avoid AliasingMove semantics Handle: C++ Smart Pointersunique_ptr shared_ptr weak_ptr usageOO Design PrincipleSummaryDesign ExercisesSection II: Strategic Type CouplingCompositionObject-oriented RelationshipsContainment (Holds-A)Composition (Has-A)ModificationReplacementPostponed instantiationEchoing an InterfaceInterfaces for Design ConsistencyWrappers and DelegatesDependency InjectionConstructor InjectionProperty (Setter) InjectionMethod InjectionDependency Injection Costs and BenefitsOO Design PrincipleSummaryDesign ExercisesInheritance Automate Type Checking PolymorphismOverloadingGenericsSubtype polymorphismFunction inliningCosts and Benefits of Polymorphism Dynamic Binding whoami() type identificationKeywords for dynamic bindingHeterogeneous CollectionsVirtual Function table Abstract ClassesInheritance designsOO Design PrincipleSummaryDesign ExercisesInheritance vs Composition Constrained InheritanceWhen Only Composition is ViableWhen Inheritance Leaks Memory: C++ destructorsInconsistent Access: C++ accessibility and bindingCode ReuseClass Design: Has-a or Is-a?Inheritance with and without Composition5Software MaintainabilityOO Design PrincipleSummaryDesign ExercisesSection III: Effective Type ReuseDesign LongevitySoftware EvolutionDisassembler ExampleVirtual Function TableType ExtractionProblematic Type ExtensionMultiple Inheritance and its SimulationDesign difficultiesSingle inheritance with compositionSimulation without inheritanceClass Hierarchies Cross-ProductsOO Design PrincipleSummaryDesign ExercisesOperator OverloadingOperators represent functionsOverloading Addition in C++Client ExpectationsOperator Overloading in C#Operators Overloaded only in C++Indexing supportI/O via the stream operatorsType conversionTransparent accessOO Design PrincipleSummaryDesign ExerciseAppendix A: The Pointer ConstructPointer definitionDereferencing pointersInappropriate use of pointersTransient versus persistent memoryReferencesThe this pointerArraysSummaryAppendix B: Design ExamplesContractual DesignOwnership: C++ class memory managementCopyingCompositionInheritanceAppendix C: Comparative Design ExamplesComposition versus InheritanceDesign longevityOperator overloadingGlossaryReferences