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…mehr
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.Hinweis: Dieser Artikel kann nur an eine deutsche Lieferadresse ausgeliefert werden.
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.
Inhaltsangabe
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
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
Es gelten unsere Allgemeinen Geschäftsbedingungen: www.buecher.de/agb
Impressum
www.buecher.de ist ein Internetauftritt der buecher.de internetstores GmbH
Geschäftsführung: Monica Sawhney | Roland Kölbl | Günter Hilger
Sitz der Gesellschaft: Batheyer Straße 115 - 117, 58099 Hagen
Postanschrift: Bürgermeister-Wegele-Str. 12, 86167 Augsburg
Amtsgericht Hagen HRB 13257
Steuernummer: 321/5800/1497
USt-IdNr: DE450055826
