Software Development with C++

Software Development with C++: Maximizing Reuse with Object Technology is about software development and object-oriented technology (OT), with applications implemented in C++. The basis for any software development project of complex systems is the process, rather than an individual method, which simply supports the overall process. This book is not intended as a general, all-encompassing treatise on OT. The intent is to provide practical information that is directly applicable to a development project. Explicit guidelines are offered for the infusion of OT into the various development phases. The book is divided into five major parts. Part I describes why we need a development process, the phases and steps of the software process, and how we use individual methods to support this process. Part II lays the foundation for the concepts included in OT. Part III describes how OT is used in the various phases of the software development process, including the domain analysis, system requirements analysis, system design, software requirements analysis, software design, and implementation. Part IV deals exclusively with design issues for an anticipated C++ implementation. Part V is devoted to object-oriented programming with C++. This book is intended for practicing software developers, software managers, and computer science and software engineering students. Sufficient guidelines are included to aid project leaders in establishing an overall development process for small, medium, and large system applications.

Part I The Software Development Process

1 Introduction

1.1 Why Do We Need a Development Process?

1.2 Why Switch to Object-Oriented Techniques?

1.3 Current Practices

2 Steps in the Development Process

2.1 Overview of the Development Process

2.2 Domain Analysis

2.3 System Requirements Analysis

2.4 System Design

2.5 Software Requirements Analysis

2.6 Software Design

2.7 Implementation

2.8 Summary

3 Development Process versus Methods

3.1 Methods That Support the Development Steps

3.2 Traditional Methods versus Object-Oriented Methods

3.3 Notation

3.4 Language Dependence

3.5 Summary

Part II Object Technology

4 Object-Oriented Paradigms

4.1 Classes and Objects

4.2 Encapsulation and Information Hiding

4.3 Data Abstraction

4.4 Responsibilities

4.5 Collaborations and Message Passing

4.6 Inheritance

4.7 Polymorphism

4.8 Binding

4.9 Modularity

4.10 Genericity

5 Classes and Objects

5.1 Definitions

5.2 Creating Classes

5.3 Inheritance and Class Hierarchies

5.4 Aggregation

5.5 Association

5.6 Using

5.7 Mixin Classes

5.8 Container Classes

5.9 Metaclasses

5.10 Reusability Issues

6 Object-Oriented Analysis and Design Models

6.1 Object-Oriented Models

6.2 Static Models

6.3 Dynamic Models

6.4 System Design Models

6.5 Concurrency Models

6.6 Functional Models

6.7 Summary

7 Object-Oriented Methods

7.1 Object Modeling Technique (OMT)

7.2 Object-Oriented Software Engineering (OOSE)

7.3 Booch'93

7.4 Shlaer-Mellor

7.5 RDD and CRCs

7.6 Coad-Yourdon

7.7 Other Methods

7.8 Summary

8 Using Object-Oriented Methods

8.1 Benefits of Object-Oriented Methods

8.2 Potential Problems with Object-Oriented Methods

8.3 When to Use Object-Oriented Methods

8.4 Mixing Object-Oriented and Structured Methods

8.5 Selecting the "Right" Method

8.6 Recommended Modeling Approach

8.7 Identifying Real-World Classes and Objects

8.8 Transitioning from Structured to OT Methods

8.9 Effect on Steps in the Development Process

8.10 Summary

Part III Using OT in the Software Development Process

9 Domain Analysis

9.1 Understanding the Problem Domain

9.2 Capturing Existing Expertise and Software

9.3 Creating Real-World Classes and Objects

9.4 Evaluation of Objects

9.5 Work Products

9.6 Risk Areas

10 System Requirements Analysis

10.1 Using Scenarios

10.2 Object-Oriented Analysis

10.3 The Analysis Model

10.4 Heuristics for Creating Analysis Objects

10.5 Refinements of Builds and Prototypes

10.6 Risk Areas

10.7 Work Products

11 System Design

11.1 Partitioning

11.2 Configuring

11.3 Summary

12 Software Requirements Analysis

12.1 Models

12.2 Object-Oriented Analysis

12.3 Creating Scenarios

12.4 Identifying Classes and Objects

12.5 Identifying Attributes and Operations

12.6 Preparing Object Views

12.7 Data Modeling

12.8 Class/Object Evaluation

12.9 Work Products

12.10 Summary

13 Software Design

13.1 Transitioning from the Analysis Phase

13.2 Process Structuring

13.3 Object-Oriented Design

13.4 OOD Products

13.5 Exception Handling

13.6 Design Evaluation

13.7 Summary

14 Implementation

14.1 Transitioning from Design

14.2 Programming

14.3 Exception Handling

14.4 Testing

14.5 Debugging

14.6 Summary

Part IV Object-Oriented Design for C++

15 Why Use C++?

15.1 Object-Oriented Languages

15.2 Benefits of C++

15.3 Potential Problems with C++

15.4 Summary

16 Transitioning from Analysis to Design

16.1 Design Goals

16.2 OOA Products

16.3 OOD Modeling Views

16.4 Transitioning Rules

16.5 Reusability Issues

17 Designing Classes

17.1 Class Design

17.2 Class Interfaces

17.3 Class Architecture

17.4 Exception Handling

17.5 Class Libraries

17.6 Frameworks

17.7 Evaluation of Class Design

17.8 Class Management

17.9 Real-Time Issues

18 C++ Concurrency Support

18.1 Programming Languages

18.2 C++ Libraries

18.3 Summary

Part V Object-Oriented Programming with C++

19 Implementing Object-Oriented Features in C++

19.1 Transitioning from Design to Programming

19.2 Types and Classes in C++

19.3 Using Structs versus Classes

19.4 Inheritance

19.5 Aggregation

19.6 Using Relationship

19.7 Constructors

19.8 Destructors

19.9 Polymorphism

19.10 Exception Handling

19.11 Templates

19.12 Performance Issues

19.13 Reusability Issues

19.14 Summary

20 Class Construction in C++

20.1 Public

20.2 Private

20.3 Protected

20.4 Friend Functions

20.5 Friend Classes

20.6 Virtual Member Functions

20.7 Abstract Base Classes

20.8 Static Members

20.9 Program Organization

20.10 Summary

21 Exception Handling in C++

21.1 Declaring Exceptions

21.2 Raising Exceptions

21.3 Handling Exceptions

21.4 Propagation of Exceptions

21.5 Exception Categories

21.6 Exception Handling in C++ Libraries

21.7 Summary

22 Developing a Windows C++ Library

22.1 Domain Analysis

22.2 System Design

22.3 Software Requirement Analysis (OOA)

22.4 Designing the Interfaces (OOD)

22.5 Implementing the Classes (OOP)

22.6 Summary

Appendix A Moving from C to C++

A.1 ANSI C and C++

A. 1.1 New Keywords

A. 1.2 Declaration of Variables

A. 1.3 Type Checking

A.2 Function Prototypes

A.3 Function Parameters

A.4 Call-by-Reference Parameters

A.5 Variable Number of Parameters

A.6 Function Overloading and Type Safe Linkage

A.7 The const Type Modifier

A.8 Classes and Structs

A.9 I/O Libraries

A.10 Inline Functions

A.11 Functions New and Delete

A.12 Organizational Issues

A.13 Strategy for Adopting C++

Appendix B C++ Coding Guidelines

B.1 Design of ADTs

B.2 Use of Classes and Structs

B.3 Class Interfaces

B.4 Virtual Functions

B.5 Inheritance

B.6 Public versus Private Derivation

B.7 Dynamic Allocation

B.8 Use of Friends

B.9 Inline Functions

B.10 Mixing C and C++ Functions

B.11 Parameter Passing

B.12 Use of Macros

B.13 Exception Handling

Appendix C Object Technology Glossary

References

Index