ABE-IPSABE HOLDINGABE BOOKS
English Polski
On-line access

Bookstore

0.00 PLN
Bookshelf (0) 
Your bookshelf is empty
Object-Oriented Design Choices

Object-Oriented Design Choices

Authors
Publisher Taylor & Francis Ltd
Year 19/01/2021
Pages 328
Version paperback
Readership level College/higher education
ISBN 9780367820183
Categories Computing: general, Programming & scripting languages: general
Delivery to United States

check shipping prices
Ask about the product
Email
question
  Send
Add to bookshelf

Book description

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.

Object-Oriented Design Choices

Table of contents

Preface


Detailed Book Outline


Section I: Stable Type Desig


Contractual Design and the Class Construct


Encapsulation


Explicit Design and Constraints



Class (Type) Functionality




Constructors




Accessors and Mutators




Utility and Public Methods




Destructors



Design as a Contract



Error Handling




Published Assumptions




Invariants


Programming by Contract Example



Contractual Expectations


OO Design Principle


Summary


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


Summary


Design Exercise





Data Integrity


Data Corruption


Copying



Shallow versus Deep Copying




C++ Copying of Internal Heap Memory



Unseen Aliasing



C# Cloning to Avoid Aliasing



Move semantics


Handle: C++ Smart Pointers


unique_ptr


shared_ptr


weak_ptr


usage


OO Design Principle


Summary


Design Exercises





Section II: Strategic Type Coupling


Composition



Object-oriented Relationships




Containment (Holds-A)




Composition (Has-A)



Modification


Replacement


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


Summary


Design Exercises





Inheritance



Automate Type Checking




Polymorphism



Overloading


Generics


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


Summary


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


Summary


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


Summary


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


Summary


Design Exercise





Appendix A: The Pointer Construct


Pointer definition


Dereferencing pointers


Inappropriate use of pointers


Transient versus persistent memory


References


The this pointer


Arrays


Summary


Appendix B: Design Examples


Contractual Design


Ownership: C++ class memory management


Copying


Composition


Inheritance


Appendix C: Comparative Design Examples


Composition versus Inheritance


Design longevity


Operator overloading


Glossary


References

We also recommend books

Strony www Białystok Warszawa
801 777 223