Large-Scale C++ Software Design

by
Format: Paperback
Pub. Date: 1996-07-10
Publisher(s): Addison-Wesley Professional
  • Free Shipping Icon

    This Item Qualifies for Free Shipping!*

    *Excludes marketplace orders.

List Price: $78.74

Buy New

Arriving Soon. Will ship when available.
$74.99

Rent Textbook

Select for Price
There was a problem. Please try again later.

Used Textbook

We're Sorry
Sold Out

eTextbook

We're Sorry
Not Available

How Marketplace Works:

  • This item is offered by an independent seller and not shipped from our warehouse
  • Item details like edition and cover design may differ from our description; see seller's comments before ordering.
  • Sellers much confirm and ship within two business days; otherwise, the order will be cancelled and refunded.
  • Marketplace purchases cannot be returned to eCampus.com. Contact the seller directly for inquiries; if no response within two days, contact customer service.
  • Additional shipping costs apply to Marketplace purchases. Review shipping costs at checkout.

Summary

In designing large-scale C++ applications, you are entering a dimension barely skimmed by most C++ books, particularly considering experience with small programming projects does not scale up to larger projects. This book unites high-level design concepts with specific C++ programming details to reveal practical methods for planning and implementing high-quality large C++ systems. You will learn the importance of physical design in large systems, how to structure your software as an acyclic hierarchy of components, and techniques for reducing link-time and compile-time dependencies. Then the book turns to logical design issues-architecting a component, designing a function, and implementing an object-all in the context of a large-project environment.

Author Biography

John Lakos works at Mentor Graphics, a company that has written more large scale C++ programs than most other software companies and was among the first companies to attempt truly large-scale C++ projects. Lakos has been programming professionally in C++ since 1987, and in 1990 developed Columbia University's graduate course in object-oriented programming which he continues to teach.



0201633620AB04062001

Table of Contents

Preface
Introduction
From C to C++
Using C++ to Develop Large Projects
Reuse
Quality
Software Development Tools
Summary
Basics
Preliminaries
Multi-File C++ Programs
Typedef Declarations
Assert Statements
A Few Matters of Style
Iterators
Logical Design Notation
Inheritance versus Layering
Minimality
Summary
Ground Rules
Overview
Member Data Access
The Global Name Space
Include Guards
Redundant Include Guards
Documentation
Identifier-Naming Conventions
Summary
Physical Design Concepts
Components
Components versus Classes
Physical Design Rules
The Depends on Relation
Implied Dependency
Extracting Actual Dependencies
Friendship
Summary
Physical Hierarchy
A Metaphor for Software Testing
A Complex Subsystem
The Difficulty in Testing "Good" Interfaces
Design for Testability
Testing in Isolation
Acyclic Physical Dependencies
Level Numbers
Hierarchical and Incremental Testing
Testing a Complex Subsystem
Testing versus Tested
Cyclic Physical Dependencies
Cumulative Component Dependency (CCD)
Physical Design Quality
Summary
Levelization
Some Causes of Cyclic Physical Dependencies
Escalation
Demotion
Opaque Pointers
Dumb Data
Redundancy
Callbacks
Manager Class
Factoring
Escalating Encapsulation
Summary
Insulation
From Encapsulation to Insulation
C++ Constructs and Compile-Time Coupling
Partial Insulation Techniques
Total Insulation Techniques
The Procedural Interface
To Insulate or Not to Insulate
Summary
Packages
From Components to Packages
Registered Package Prefixes
Package Levelization
Package Insulation
Package Groups
The Release Process
The main Program
Start-Up Time
Summary
Logical Design Issues
Architecting a Component
Abstractions and Components
Component Interface Design
Degrees of Encapsulation
Auxiliary Implementation Classes
Summary
Designing a Function
Function Specification
Fundamental Types Used in the Interface
Special Case Functions
Summary
Implementing an Object
Member Data
Function Definitions
Memory Management
Using C++ Templates in Large Projects
Summary
Protocol Hierarchy
Implementing an ANSI C-Compatible C++ Interface
A Dependency Extractor/Analyzer Package
Quick Reference
Index
Table of Contents provided by Publisher. All Rights Reserved.

Excerpts

As a member of the IC Division at Mentor Graphics Corporation, I am fortunate to have worked with many bright, talented software engineers, developing very large systems.Back in 1985, Mentor Graphics became one of the first companies to attempt a truly large project in C++. Back then no one knew how to do that, and no one could have anticipated the cost overruns, slipped schedules, huge executables, poor performance, and incredibly expensive build times that a naive approach would inevitably produce.Many valuable lessons were learned along the way - knowledge obtained through bitter experience. There were no books to help guide the design process; object-oriented designs on this scale had never before been attempted.Ten years later, with a wealth of valuable experience under its belt, Mentor Graphics has produced several large software systems written in C++, and in doing so has paved the way for others to do the same without having to pay such a high price for the privilege.During my 13 years as a C (turned C++) Computer-Aided Design (CAD) software developer, I have seen over and over again that planning ahead invariably produces a higher-quality, more maintainable product. My emphasis at Mentor Graphics has been on helping to ensure that quality is an integral part of the design process from the very start.In 1990 I developed the graduate course "Object-Oriented Design and Programming" at Columbia University. As the instructor of this course since 1991, I have had the opportunity to share many of the insights that we at Mentor Graphics gained during our industrial-strength software development efforts. Questions and feedback from literally hundreds of graduate students and professional programmers have helped me to crystallize many important concepts. This book is a direct result of that experience. To my knowledge, this is the first text that identifies development and quality issues that arise only in large C++ projects. I hope that this information will be as useful in your work as it is in mine. Audience Large-Scale C++ Software Designwas written explicitly for experienced C++ software developers, system architects, and proactive quality-assurance professionals. This book is particularly appropriate for those involved in large development efforts such as databases, operating systems, compilers, and frameworks.Developing a large-scale software system in C++ requires more than just a sound understanding of the logical design issues covered in most books on C++ programming. Effective design also requires a grasp of physical design concepts that, although closely tied to the technical aspects of development, include a dimension with which even expert professional software developers may have little or no experience.Yet most of the advice presented in this book also applies to small projects. It is typical for a person to start with a small project and then begin to take on larger and more challenging enterprises. Often the scope of a particular project will expand, and what starts out as a small project becomes a major undertaking. The immediate consequences of disregarding good practice in a large project, however, are far more severe than they are for disregarding good practice in a smaller project.This book unites high-level design concepts with specific C++ programming details to satisfy two needs: An object-oriented design book geared specifically to practical aspects of the C++ programming language. A C++ programming book describing how to use the C++ programming language to develop very large systems. Make no mistake, this is an advanced text. This is not the book from which to learn C++ syntax for the first time, nor is it likely to expose you to the dark corners of the language. Instead, this book will show you how to use the full power of the C++ language in ways that scale well to very large systems.In short, if you feel that you know C++ well, but w

An electronic version of this book is available through VitalSource.

This book is viewable on PC, Mac, iPhone, iPad, iPod Touch, and most smartphones.

By purchasing, you will be able to view this book online, as well as download it, for the chosen number of days.

Digital License

You are licensing a digital product for a set duration. Durations are set forth in the product description, with "Lifetime" typically meaning five (5) years of online access and permanent download to a supported device. All licenses are non-transferable.

More details can be found here.

A downloadable version of this book is available through the eCampus Reader or compatible Adobe readers.

Applications are available on iOS, Android, PC, Mac, and Windows Mobile platforms.

Please view the compatibility matrix prior to purchase.