A Practical Introduction to Object-Oriented Design with C++

by Reiss, Steven P.

• ISBN13: 9780471242130
• ISBN10: 0471242136
• Edition: 1st
• Format: Paperback
• Copyright: 1998-10-23
• Publisher: Wiley

Summary

Learn the tools and techniques needed to design and implement moderate-sized software systems! Do you want to gain the necessary skills to effectively write moderate-sized (10,000 to 50,000 line) programs? Would you like to develop a more advanced understanding of object-oriented design and learn how to implement important design and style rules? Do you want to be able to take a project from the concept stage to completion? This is all possible with Steven Reiss's innovative text, A Pracical Introduction to Software Design with C++. Reiss provides you with all the tools and techniques to enable you to design and implement moderate-sized software systems alone or in a team. The book details the proper use of inheritance, design notations using a simplified form of OMT to describe designs, the use of object libraries such as STL, creating library classes, and the use of design patterns. You'll also find useful discussions on advanced language and programming features such as exception handling, interprocess communication, and debugging tools and techniques.

Author Biography

<b>Steven P. Reiss</b> is a full Professor in the Department of Computer Science at Brown University. Professor Reiss received his Ph.D. in Computer Science from Yale University. He has served as program committee chair for several ACM special interest groups including Sigplan and Sigsoft. In 1994, he authored the book Field: A Friendly Interactive Environment for Learning and Development.

Table of Contents

Chapter 1 What Is Object-Oriented Design?	1	(16)
What Is Design?	1	(5)
Abstraction and Hierarchy in Design	3	(1)
Procedural and Data-Oriented Design	4	(2)
Object-Oriented Design	6	(8)
Object-Oriented Design Methodology	9	(4)
Design Simplicity	13	(1)
Outline of the Text	14	(2)
Exercises	16	(1)
Chapter 2 A Simple Example of Object-Oriented Design	17	(30)
The Knight's-Tour Problem	17	(3)
Identifying Candidate Classes	20	(7)
Categories of Classes	23	(1)
Choosing the Top-Level Classes	24	(3)
Characterizing the Classes	27	(3)
Describing Object-Oriented Designs	28	(2)
Defining the Implementation	30	(9)
Evaluating a Design	39	(5)
Simplicity	41	(1)
Cohesion and Coupling	42	(1)
Information Hiding	43	(1)
Error Handling	43	(1)
Summary	44	(1)
Exercises	45	(2)
Chapter 3 Implementing an Object-Oriented Design	47	(30)
Coding Conventions	47	(6)
Naming Conventions	48	(2)
Standard Types	50	(1)
Pointers and Objects	51	(1)
Constants	52	(1)
Writing the Class Declarations	53	(3)
Writing The Methods	56	(11)
KnightMainInfo	56	(3)
KnightBoardInfo	59	(1)
KnightSquareInfo	60	(4)
KnightHeuristicInfo	64	(2)
KnightSolutionInfo	66	(1)
File Structure	67	(6)
Header Files	68	(4)
Code Files	72	(1)
Summary	73	(1)
Exercises	74	(3)
Chapter 4 How to Use C++ Effectively	77	(28)
Classes as Pointers	77	(2)
Class Implementations	79	(10)
Protection	79	(2)
Constant Declarations	81	(1)
Parameters	82	(1)
Overloading	83	(3)
Operator Methods	86	(3)
Class Variables	89	(1)
C++ Storage Management	89	(8)
Constructors	89	(4)
Destructors	93	(1)
Safe Memory Management	93	(4)
C++ Types	97	(4)
Typedefs	97	(1)
Enumerations	98	(1)
Pointer Types	99	(1)
Conversion Functions	99	(2)
Comments	101	(1)
Summary	102	(1)
Exercises	103	(2)
Chapter 5 Designing with Inheritance	105	(28)
Symbolic Differentiation	105	(3)
Natural Inheritance	108	(7)
Designing a Natural Hierarchy	110	(3)
Special Cases of Natural Inheritance	113	(2)
Interface Inheritance	115	(5)
Factory Classes	116	(2)
Whapper Classes	118	(2)
Mix-in Inheritance	120	(3)
Inheritance for Callbacks	123	(3)
Behavior Inheritance	126	(2)
Guidelines for Using Inheritance In C++	128	(3)
Levels of Inheritance	128	(1)
Multiple Inheritance	129	(1)
Virtual Methods	130	(1)
Summary	131	(1)
Exercises	132	(1)
Chapter 6 Design Notations	133	(26)
Design Notations	134	(1)
Static Structure Diagram Basics	135	(5)
Class Notations	136	(1)
Relationship Notations	137	(3)
Expressing Designs Using Diagrams	140	(7)
Top-Level Design	140	(4)
Second-Level Designs	144	(3)
Message-Trace Diagrams	147	(7)
Using Design Diagrams	154	(3)
Summary	157	(1)
Exercises	158	(1)
Chapter 7 Using Object-Oriented Libraries	159	(30)
Object Libraries	159	(3)
Types of Libraries	159	(2)
Dependency Analyzer	161	(1)
Independent Objects	162	(4)
Dependent Objects	166	(8)
Dynamic Vectors and Lists	168	(2)
Associative Containers	170	(4)
Iterators	174	(5)
The Rest of the Library	179	(8)
Data-Structure Classes	179	(1)
Algorithm Classes	180	(7)
Summary	187	(1)
Exercises	188	(1)
Chapter 8 Debugging and Testing	189	(36)
Debugging and Testing	189	(2)
Defensive Programming	191	(12)
Defensive Design	191	(4)
Defensive Coding	195	(3)
Assertions	198	(1)
Exceptions	199	(1)
An Example	200	(3)
Debugging Tools	203	(4)
Debugging Techniques	207	(9)
Error Location	208	(5)
Error Logging	213	(1)
Error Repair	214	(1)
Memory-Management Problems	215	(1)
Testing	216	(5)
Approaches to Testing	217	(2)
Test Case Selection	219	(2)
Summary	221	(1)
Exercises	222	(3)
Chapter 9 Graphical Application Concepts	225	(28)
A Sample Graphical Application	226	(2)
Program Structure	228	(4)
Control Structure	232	(3)
User-Interface Concepts	235	(4)
Basic Motif Concepts	236	(2)
Basic Microsoft Foundation Class Concepts	238	(1)
User-Interface Components	239	(8)
Motif Components	240	(4)
Microsoft Foundation Classes Components	244	(3)
Graphical Output	247	(3)
Summary	250	(1)
Exercises	251	(2)
Chapter 10 Designing Graphical Applications	253	(22)
Sketching the Interface	253	(3)
User-Interface Classes	258	(2)
User-Interface Methods	260	(1)
Managing the Drawing	261	(3)
Managing the Dialog Boxes	264	(4)
Implementing the User Interface	268	(4)
Implementation Strategy	269	(3)
Summary	272	(1)
Exercises	272	(3)
Chapter 11 User-Interface Design	275	(24)
Human Factors	275	(1)
User-Interface Problems	276	(4)
Lack of Conventions	276	(1)
Overly Complex Displays	277	(1)
Lack of Elegance	278	(1)
Intolerance to Error	279	(1)
Bad Documentation	279	(1)
Design Guidelines	280	(7)
Common Sense	280	(1)
Consistency	281	(1)
Feedback	282	(1)
Design for Error	283	(2)
Types of Users	285	(1)
Evaluation	286	(1)
Visual Guidelines	287	(7)
Visual Clarity	287	(3)
Visual Codings	290	(1)
Principles of Layout	291	(2)
Color	293	(1)
User-Interface Models	294	(2)
Summary	296	(1)
Exercises	297	(2)
Chapter 12 Creating Object Libraries	299	(28)
Reuse and Objects	299	(3)
Implementing Reuse	299	(1)
Why Reuse is Difficult	300	(2)
Designing Reusable Classes	302	(9)
Selecting Classes to Reuse	302	(2)
Defining a Reusable Class	304	(3)
Selecting the Level of Reuse	307	(4)
Reuse Through Inheritance	311	(3)
Defining Inheritable Classes	311	(1)
Inheritance for Callbacks	312	(1)
Application Frameworks	313	(1)
Templates	314	(5)
Creating a Template	315	(1)
Designing Template Classes	316	(6)
Specializing Templates	322	(3)
Summary	325	(1)
Exercises	325	(2)
Chapter 13 Design Patterns	327	(30)
What Is a Design Pattern?	327	(3)
Factory Patterns	330	(6)
Builder	330	(2)
Abstract Factory	332	(1)
Flyweight	333	(1)
Singleton	334	(1)
Factory Method	335	(1)
Prototype	335	(1)
Delegating Responsibility	336	(6)
Adaptor	336	(1)
Bridge	337	(2)
Decorator	339	(1)
Facade	339	(2)
Proxy	341	(1)
Control Patterns	342	(8)
Composite	342	(1)
Interpreter	342	(1)
Command	343	(1)
Iterator	344	(1)
Strategy	345	(1)
Template	346	(2)
Visitor	348	(2)
Algorithmic Patterns	350	(3)
Mediator	350	(2)
Memento	352	(1)
Observer	353	(1)
Summary	353	(2)
Exercises	355	(2)
Chapter 14 Multiple-Process Programming	357	(40)
Interprocess Communication	358	(3)
Files	359	(1)
Shared Memory	359	(1)
Messaging	360	(1)
Sockets	361	(4)
A Simple Socket Interface	362	(3)
Messaging	365	(3)
A Messaging Class Interface	366	(1)
Implementing Messaging Using Sockets	367	(1)
Remote Objects	368	(15)
Basic Concepts	369	(3)
Designing with Remote Objects	372	(3)
Implementing Remote Objects	375	(8)
ActiveX and CORBA	383	(1)
Multiple Threads of Control	383	(10)
Designing for Multiple Threads of Control	385	(2)
Synchronization Mechanisms	387	(2)
Multithreading the Chat Server	389	(4)
Summary	393	(1)
Exercises	394	(3)
Chapter 15 Software Engineering	397	(28)
The Foundations of Software Engineering	397	(7)
The Problems of Software	398	(1)
Software Engineering	399	(2)
Software Quality	401	(1)
Software Management	402	(2)
The Phases of Software Engineering	404	(12)
Requirements Analysis	405	(1)
Specifications	406	(6)
Design	412	(2)
Coding	414	(1)
Testing	414	(1)
Operation and Maintenance	415	(1)
The Software Development Process	416	(5)
The Waterfall Model	416	(3)
Prototypes and the Spiral Model	419	(2)
Summary	421	(2)
Exercises	423	(2)
Chapter 16 Writing Larger Systems	425	(40)
Getting Started	426	(3)
Requirements Analysis and Specifications	426	(1)
Design	427	(2)
Design By Subsystem	429	(1)
Risk-Based Design	430	(5)
Building a Design Model	431	(1)
Identifying Difficult Problems	432	(1)
Solving the Difficult Problems	433	(2)
Core-Plus-Extensions Design	435	(6)
Pros and Cons	436	(1)
Defining the Core	437	(4)
Interface Definition	441	(6)
Finding Initial Methods	442	(4)
Evolving the Interface	446	(1)
Other Design Issues	447	(4)
Portability	447	(1)
Extensibility	448	(1)
Existing Frameworks	449	(2)
Managing a Software Project	451	(11)
Personnel Management	451	(2)
Design Management	453	(1)
Code Management	454	(2)
Configuration Management	456	(1)
Testing Management	457	(2)
Documentation	459	(3)
Conclusion	462	(1)
Summary	463	(1)
Exercises	464	(1)
Appendix A Sample Coding Standards	465	(12)
Purpose	465	(1)
Naming Conventions	465	(3)
Files	466	(1)
Types, Variables, and Constants	466	(2)
Commenting Conventions	468	(3)
Block Comments	468	(1)
Inline Comments	469	(1)
The Readme File	470	(1)
White Space	470	(1)
Order Does Matter	470	(1)
Breaking Up Your Code	471	(1)
Source and Header Files	471	(1)
Including a Header File Multiple Times	471	(1)
Small Generic Functions	472	(1)
Glossary	472	(1)
Closing Thoughts	472	(1)
Sample Code	473	(4)
Header File Example	473	(1)
Code File Example	474	(3)
Appendix B The Knight's-Tour Program	477	(18)
Knight-local.H	478	(4)
Knight.cxx	482	(1)
Knightmain.cxx	483	(1)
Knightboard.cxx	485	(2)
Knightsquare.cxx	487	(3)
Knightheuristic.cxx	490	(2)
Knightsolution.cxx	492	(3)
Appendix C The Dependency Analyzer	495	(12)
depend_local.H	496	(3)
dependmain.cxx	499	(2)
Dependnode.cxx	501	(2)
Dependnodeset.cxx	503	(4)
Index	507