UML and C++ : A Practical Guide to Object-Oriented Development

by Richard C. Lee; William M. Tepfenhart

• ISBN13: 9780136197195
• ISBN10: 0136197191
• Format: Paperback
• Copyright: 1997-04-01
• Publisher: Prentice Hall Professional Technical Reference

Summary

If you are interested in learning object-oriented technology using UML (Unified Modeling Language) and C++, then this guide from two leading software developers at Bell Laboratories of Lucent Technologies and AT&T is for you. Designed as a self-teaching guide for busy software analysts and developers who work on large systems, this book will teach you how to actually do object-oriented modeling using UML notation and implementing the model using C++. Features: Uses the new UML notation for documentation. UML will be the new industry standard; teaches the professional to make and trade off decisions to meet business needs; explains the differences among object-oriented analysis, object-oriented design, and object-oriented programming; provides a strategy for employing all the steps of object-oriented technology; fully worked case study that takes the reader through the entire development process; every concept is introduced with an example.

Table of Contents

1 The Information Management Dilemma	1	(5)
The Problem	2	(1)
Modern Corporations Are Headed Toward Disaster	3	(1)
What Does the Customer Want?	3	(1)
Why Object-Oriented Technology Is Important to Developers	4	(2)
2 Managing Complexity: Analysis and Design	6	(15)
Abstraction Mechanism	8	(3)
Functions	8	(1)
Modules	9	(1)
Abstract Data Types	10	(1)
Classes/Objects	11	(1)
Message Passing	11	(1)
Generalization/Specialization and Polymorphism	12	(1)
Additional Relationships	12	(4)
Associations	13	(1)
Aggregation	14	(2)
Behavior	16	(2)
Static Behavior	16	(1)
Dynamic Behavior	16	(2)
Rules	18	(1)
Complex Systems	19	(2)
3 Object-Oriented Programming	21	(19)
What Is Object-Oriented Programming?	22	(1)
Not a Silver Bullet	22	(1)
New Paradigm	22	(1)
Basic Object-Oriented Programming Concepts	22	(5)
Object-Oriented Programming Languages	27	(1)
Object-Based Programming	27	(1)
Class-Based Programming	27	(1)
Object-Oriented Programming	27	(1)
Advanced Object-Oriented (OO) Programming	28	(1)
Leading-Edge Object-Oriented Programming	28	(1)
Why C++?	28	(1)
Ways of Organizing Reality	29	(2)
The Simulation Model of Computation	31	(1)
The Object-Oriented Way of Organizing Reality	32	(8)
4 Finding the Objects	40	(18)
Object-Oriented Analysis: Model of Reality	41	(1)
Building the OO Model	41	(1)
Identification of Objects	42	(2)
Current Techniques	44	(6)
Using the Things to Be Modeled	45	(1)
Using the Definitions of Objects and Classes	45	(1)
Using Object Decomposition	45	(1)
Using Generalization	46	(1)
Using Subclasses	46	(1)
Using Object-Oriented Domain Analysis	47	(1)
Reusing an Application Framework	47	(1)
Reusing Class Hierarchies	48	(1)
Reusing Individual Objects and Classes	48	(1)
Using Subassemblies	48	(1)
Using Personal Experience	49	(1)
Traditional Techniques	50	(3)
Using Nouns	50	(1)
Using Traditional Data Flow Diagrams	51	(1)
Using Class-Responsibility-Collaboration (CRC) Cards	52	(1)
Recommended Approaches	53	(5)
Example	55
5 Identifying Responsibilities	58	(13)
What Is an Object?	59	(1)
What Is an Attribute?	60	(1)
Descriptive Attributes	60	(1)
Naming Attributes	61	(1)
What Is a Service?	61	(1)
What Is a Method?	61	(1)
Identifying Attributes	62	(2)
Specifying Attributes	64	(1)
Identifying Services	65	(1)
Specifying Services	66	(1)
Recommended Approach	66	(1)
Example	67	(4)
6 Specifying Static Behavior	71	(14)
What Is Behavior?	72	(1)
Techniques for Specifying Static Behavior	73	(2)
Techniques for Specifying Control	75	(1)
Techniques for Documenting Control	76	(2)
Process Flow Diagrams	76	(1)
Object Interaction Diagram (Collaboration Diagram)	76	(1)
Event Trace Diagram (Sequence Diagram)	77	(1)
The Use-Case Model	77	(1)
Techniques for Documenting Static Behavior	78	(1)
Preconditions and Postconditions	78	(1)
Flowcharting	78	(1)
Data Flow Diagrams	78	(1)
Structured English	78	(1)
Recommended Approach	79	(1)
Example	80	(5)
7 Dynamic Behavior	85	(20)
Introduction	86	(1)
Techniques for Identifying Dynamic Behavior	87	(4)
Common Lifecycle Forms	89	(1)
Models for Capturing the Lifecycle	89	(2)
Identifying and Specifying Events	91	(3)
Use Case and Scenario	91	(1)
Event Trace Diagram	92	(1)
Example	92	(2)
Specifying Dynamic Behavior	94	(7)
Event List	94	(3)
State Transition Table	97	(4)
Documenting Dynamic Behavior	101	(2)
State Diagrams	101	(2)
Recommended Approach	103	(2)
8 Identifying Relationships	105	(24)
Accessing Another Object's Services	106	(1)
Relationships	106	(1)
Generalization	107	(3)
Identifying and Specifying Generalization/Specialization	110	(1)
Object Aggregation	111	(1)
Classification of Aggregation	112	(6)
Assembly-parts (Component-Integral Composition)	113	(1)
Material-Object Composition	114	(1)
Portion-Object Composition	115	(1)
Place-Area Composition	116	(1)
Collection-Members Composition	116	(1)
Container-Content (Member-Bunch Composition)	117	(1)
Member-Partnership Composition	117	(1)
Objects and Aggregation Relationships	118	(1)
Links Between Objects	118	(2)
Identifying and Specifying Links and Aggregations	120	(1)
Managing Relationships	121	(2)
Documenting Relationships	123	(2)
Recommended Approach	125	(4)
Example	126	(3)
9 Rules	129	(10)
Introduction	130	(1)
Rules	131	(1)
Identifying Declarative Statements	131	(2)
Specifying and Documenting Rules	133	(1)
Mapping Rules to the Proper Object-Oriented Concepts	134	(2)
Documenting the Rules Using UML	136	(1)
Implementing Rules	136	(1)
Recommended Approach	137	(2)
10 The Model	139	(17)
Concepts	140	(1)
Concepts and Object-Oriented Model	141	(3)
Class	141	(1)
Association	141	(1)
Class Aggregation	142	(1)
Generalization/Specialization	142	(1)
Polymorphism	143	(1)
Instantiation	144	(1)
Refining the Model	144	(1)
Subsystems	145	(1)
Domain	145	(1)
Bridge	146	(1)
Organizing Subsystems	146	(2)
Horizontal Layers	147	(1)
Vertical Partitions	147	(1)
Combination	148	(1)
Identifying Subsystems	148	(1)
Recommended Approach	148	(8)
Example	149	(7)
11 Design	156	(16)
Introduction	157	(1)
System Design	158	(4)
Subsystems	158	(1)
Architectural Frameworks	159	(3)
Detailed Design	162	(10)
Class Design	162	(2)
Association Design	164	(1)
Generalization and Inheritance	165	(1)
Delegation	166	(1)
Orlando Treaty	167	(1)
Multiple Inheritance	168	(4)
12 C++ Fundamentals	172	(19)
History	173	(1)
Programming Elements	173	(3)
Keywords	174	(1)
Identifiers	174	(1)
Literals	175	(1)
Operators	175	(1)
Punctuators	175	(1)
Native Data Types	176	(5)
Basic Data Types	177	(1)
Constant Values	177	(1)
Symbolic Variables	178	(1)
Pointer Types	178	(1)
Constant Types	179	(1)
Reference Types	180	(1)
Enumeration Types	180	(1)
Array Types	180	(1)
Typedef Names	181	(1)
What Is a Statement?	181	(1)
Expressions	182	(1)
Compound Statements	182	(1)
Statement Flow Control	182	(2)
If statement	183	(1)
For statement	183	(1)
What Is a Function?	184	(1)
Function Invocation	185	(3)
Function Definition	186	(1)
Function Prototype	187	(1)
Inlining	187	(1)
Storage Class	188	(3)
Auto	188	(1)
Extern	188	(1)
Register	188	(1)
Static	189	(2)
13 Implementing Class	191	(9)
Components of a Class	192	(1)
Class Definition	192	(1)
Class Body	193	(3)
Visibility	193	(1)
Data Members	193	(2)
Member Functions	195	(1)
Generalization Using Inheritance	196	(1)
Recommended Approach	197	(3)
Example	198	(2)
14 Implementing Static Behavior	200	(17)
Function Definition	201	(4)
Return Type	202	(1)
Return Statement	202	(1)
Function Argument List	203	(2)
Passing Arguments	205	(3)
Pass-by-Value	205	(1)
Reference or Pointer Argument	206	(2)
Return Type as Reference or Pointer	208	(1)
Casting	209	(1)
Const and Defaults	210	(2)
Const	210	(2)
Default Initializers	212	(1)
Identifier Scope	212	(1)
Recommended Approach	213	(4)
Definition in the .h file	213	(1)
Definition in the .C file	214	(3)
15 Instantiating and Deleting Objects	217	(13)
Introduction	218	(1)
Constructors	218	(3)
Destructors	221	(3)
Using Constructors and Destructors Properly	224	(1)
Generalization and Constructors	225	(1)
Recommended Approach	226	(2)
Creating an Object	226	(1)
Destroying an Object	227	(1)
Coding Guidelines	228	(2)
Constructors	228	(1)
Destructors	229	(1)
16 Implementing Generalization/Specialization	230	(19)
Inheritance	31
Specifying a Derived Class	231	(2)
Inheriting from a Derived Class and Implementing Association	233	(2)
Adding Polymorphism	235	(3)
Abstract Class	238	(1)
Multiple Inheritance	239	(6)
Virtual Destructors	245	(1)
Derived Class Visibility	246	(3)
17 Implementing More Relationships	249	(19)
Introduction	250	(1)
Implementing Association	250	(1)
Implementing Attributes of an Association	251	(1)
Implementing Aggregation	251	(1)
Pointers	251	(2)
Arrays	253	(2)
Friends	255	(1)
Static Members	256	(1)
Implementing Association	257	(2)
Binary Association	257	(1)
Many-to-One Association	257	(2)
Many-to-Many Association	259	(1)
Implementing Friends	259	(4)
Class as a Friend	260	(1)
Function as a Friend	260	(1)
Implementing a One-to-Many Association Using a Friend	261	(2)
Implementing Aggregation	263	(2)
Buried Pointers	263	(1)
Embedded Objects	264	(1)
Implementing Static Members	265	(2)
Recommended Approach	267	(1)
18 Case Study: Breakout	268	(21)
Requirements	269	(1)
Acquiring Domain Expertise	270	(1)
Expert's Knowledge	271	(1)
Mechanics of Breakout	271	(1)
Time Sequencing in Simulations	271	(1)
Provided Technology Services	272	(3)
Detailed Class Descriptions	275	(11)
Geometric Subsystem Classes	275	(2)
Display Subsystem Classes	277	(7)
Collision Subsystem Classes	284	(2)
UML Description of the Subsystems	286	(3)
Geometric Subsystem	286	(1)
Display Subsystem	286	(1)
Collision Subsystem	286	(3)
19 Case Study: Team 1	289	(29)
Step 1: Finding the Objects	290	(1)
Step 2: Identifying Responsibilities	290	(12)
Step 3: Specifying Behaviors	302	(9)
Step 4: Specifying Relationships	311	(4)
Step 5: Refinement	315	(3)
20 Case Study: Team 2	318	(56)
Step 1: Finding The Objects	319	(1)
Step 2: Identifying Responsibilities	320	(18)
Step 3: Specifying Behaviors	338	(9)
Step 4: Specifying Relationships	347	(7)
Step 5: Refinement	354	(20)
21 Case Study: Design & Implementation	374	(62)
Design	375	(9)
Implementing Class	384	(14)
Implementing Static Behavior	398	(3)
Instantiating Objects	401	(4)
Implementing Inheritance	405	(21)
Implementing Relationships	426	(10)
Bibliography	436	(3)
Index	439