1st Edition

Object-Oriented Design Choices

By Adair Dingle Copyright 2021
    348 Pages 14 B/W Illustrations
    by Chapman & Hall

    348 Pages 14 B/W Illustrations
    by Chapman & Hall

    348 Pages 14 B/W Illustrations
    by Chapman & Hall

    Do modern programming languages, IDEs, and libraries make coding easy? Maybe, but coding is not design. Large-scale or expensive apps clearly require evaluation of design choices. Still, software design directly impacts code reuse and longevity even for small-scale apps with limited overhead. This text evaluates and contrasts common object-oriented designs.

    A given problem may have many solutions. A developer may employ different design techniques – composition, inheritance, dependency injection, delegation, etc. – to solve a particular problem. A skilled developer can determine the costs and benefits of different design responses, even amid competing concerns. A responsible developer documents design choices as a contract with the client, delineating external and internal responsibilities. To promote effective software design, this book examines contractual, object-oriented designs for immediate and sustained use as well as code reuse. The intent of identifying design variants is to recognize and manage conflicting goals such as short versus long-term utility, stability versus flexibility, and storage versus computation. Many examples are given to evaluate and contrast different solutions and to compare C# and C++ effects. No one has a crystal ball; however, deliberate design promotes software longevity. With the prominence of legacy OO code, a clear understanding of different object-oriented designs is essential.

    Design questions abound. Is code reuse better with inheritance or composition? Should composition rely on complete encapsulation? Design choices impact flexibility, efficiency, stability, longevity, and reuse, yet compilers do not enforce design and syntax does not necessarily illustrate design. Through deliberate design, or redesign when refactoring, developers construct sustainable, efficient code.


    Detailed Book Outline

    Section I:  Stable Type Desig

    Contractual Design and the Class Construct


    Explicit Design and Constraints

    Class (Type) Functionality


    Accessors and Mutators

    Utility and Public Methods


    Design as a Contract

    Error Handling

    Published Assumptions


    Programming by Contract Example

    Contractual Expectations

    OO Design Principle


    Design Exercises

    Ownership – Abstracted but Tracked

    The Abstraction of Memory 

    Heap Memory

    Ownership of Heap Objects

    Array Allocation

    Design Intervention

    Persistent Data

    Class Design  

    Memory Reclamation

    C++ Explicit Deallocation

    Garbage Collection

    Reference Counting

    Design: Storage vs Computation 

    OO Design Principle


    Design Exercise


    Data Integrity

    Data Corruption


    Shallow versus Deep Copying

    C++ Copying of Internal Heap Memory

    Unseen Aliasing

    C# Cloning to Avoid Aliasing

    Move semantics 

    Handle: C++ Smart Pointers





    OO Design Principle


    Design Exercises


    Section II: Strategic Type Coupling


    Object-oriented Relationships

    Containment (Holds-A)

    Composition (Has-A)



    Postponed instantiation

    Echoing an Interface

    Interfaces for Design Consistency

    Wrappers and Delegates

    Dependency Injection

    Constructor Injection

    Property (Setter) Injection

    Method Injection

    Dependency Injection Costs and Benefits

    OO Design Principle


    Design Exercises



    Automate Type Checking 




    Subtype polymorphism

    Function inlining

    Costs and Benefits of Polymorphism 

    Dynamic Binding 

    whoami() type identification

    Keywords for dynamic binding

     Heterogeneous Collections

    Virtual Function table 

    Abstract Classes

    Inheritance designs

    OO Design Principle


    Design Exercises

    Inheritance vs Composition  

    Constrained Inheritance

    When Only Composition is Viable

    When Inheritance Leaks Memory:  C++ destructors

    Inconsistent Access: 

    C++ accessibility and binding

    Code Reuse

    Class Design: Has-a or Is-a?

    Inheritance with and without Composition

    5Software Maintainability

    OO Design Principle


    Design Exercises


    Section III:  Effective Type Reuse

    Design Longevity

    Software Evolution

    Disassembler Example

    Virtual Function Table

    Type Extraction

    Problematic Type Extension

    Multiple Inheritance and its Simulation

    Design difficulties

    Single inheritance with composition

    Simulation without inheritance

    Class Hierarchies Cross-Products

    OO Design Principle


    Design Exercises

    Operator Overloading

    Operators represent functions

    Overloading Addition in C++

    Client Expectations

    Operator Overloading in C#

    Operators Overloaded only in C++

    Indexing support

    I/O via the stream operators

    Type conversion

    Transparent access

    OO Design Principle


    Design Exercise


    Appendix A:   The Pointer Construct

    Pointer definition

    Dereferencing pointers

    Inappropriate use of pointers

    Transient versus persistent memory


    The this pointer



    Appendix B:   Design Examples

    Contractual Design

    Ownership:  C++ class memory management




    Appendix C:   Comparative Design Examples

    Composition versus Inheritance

    Design longevity

    Operator overloading




    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 Brunswick

    Review in April 2022 Issue of CHOICE