Lakos John. Large-Scale C++ Software Design

Addison Wesley Longman, Inc. 1997. — 870 p.
'Large-Scale C++ Software Design' was 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 p.articular 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:
1. An object-oriented design book geared specifically to practical aspects of the C++ programming language.
2. 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 would like to understand more about how to use the language effectively on large projects, this book is for you.Пояснение:
Ранее выкладывалась эта же книга в формате PDF. Исходный скан у них общий. Текстовый слой разный. В обоих случаях он не идеален, местами один лучше, местами другой. Фрагмненты исходного кода распознаны с ошибками, перед использованием их придётся править.
Интерактивного оглавления также нет.Chapter 0: Introduction
From C to C++
Using C++ to Develop Large Projects
CyclicDependencies
Excessive Link-Time Dependencies
Excessive Compile-Time Dependencies
The Global Name Space
Logical vs. Physical Design
Reuse
Quality
Quality Assurance
Quality Ensurance
Software Development ToolsI: BASICS
Chapter 1: Preliminaries
Multi-File C++ Programs
Declaration versus Definition
Internal versus External Linkage
Header(.h) Files
Implementation(.c) Files
typedef Declarations
Assert Statements
A Few Matters of Style
Identifier Names
Type Names
Multi-Word Identifier Names
Data Member Names
Class Member Layout
Iterators
Logical Design Notation
The IsA Relation
The Uses-In-The-Interface Relation
The Uses-In-The-Implementation Relation
Uses
HasA and HoldsA
WasA
Inheritance versus Layering
MinimalityChapter 2: Ground Rules
Overview
Member Data Access
The Global Name Space
Global Data
Free Functions
Enumerations, Typedefs, and Constant Data
Preprocessor Macros
Names in Header Files
Include Guards
Redundant Include Guards
Documentation
Identifier-Naming ConventionsII: PHYSICAL DESIGN CONCEPTS
Chapter 3: Components
Components versus Classes
Physical Design Rules
The DependsOn Relation
Implied Dependency
Extracting Actual Dependencies
Friendship
Long-Distance Friendship and Implied Dependency
Friendship and FraudChapter 4: 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
The Origin of Level Numbers
Using Level Numbers in Software
Hierarchical and Incremental Testing
Testing a Complex Subsystem
Testability versus Testing
Cyclic Physical Dependencies
Cumulative Component Dependency
Physical Design QualityChapter 5: Levelization
Some Causes of Cyclic Physical Dependencies
Enhancement
Convenience
Intrinsic Interdependency
Escalation
Demotion
Opaque Pointers
Dumb Data
Redundancy
Callbacks
Manager Class
Factoring
Escalating EncapsulationChapter 6: Insulation
From Encapsulation to Insulation
The Cost of Compile-Time Coupling
C++ Constructs and Compile-Time Coupling
Inheritance (IsA) and Compile-Time Coupling
Layering (HasA / HoldsA) and Compile-Time Coupling
Inline Functions and Compile-Time Coupling
Private Members and Compile-Time Coupling
Protected Members and Compile-Time Coupling
Compiler-Generated Member Functions and Compile-Time CoupUng
Include Directives and Compile-Time Coupling
Default Arguments and Compile-Time Coupling
Enumerations and Compile-Time Coupling
Partial Insulation Techniques
Removing Private Inheritance
Removing Embedded Data Members
Removing Private Member Functions
Removing Protected Members
Removing Private Member Data
Removing Compiler-Generated Functions
Removing Include Directives
Removing Default Arguments
Removing Enumerations
Total Insulation Techniques
The Protocol Class
The Fully Insulating Concrete Class
The Insulating Wrapper
Single-Component Wrappers
Multi-Component Wrappers
The Procedural Interface
The Procedural Interface Architecture
Creating and Destroying Opaque Objects
Handles
Accessing and Manipulating Opaque Objects
Inheritance and Opaque Objects
To Insulate or Not to Insulate
The Cost of Insulation
When Not to Insulate
How to Insulate
How Much to InsulateChapter 7: Packages
From Components to Packages
Registered Package Prefixes
The Need for Prefixes
Namespaces
Preserving Prefix Integrity
Package Levelization
The Importance of Levelizing Packages
Package Levelization Techinques
itioning a System
Multi-Site Development
Package Insulation
Package Groups
The Release Process
The Release Structure
Patches
The main Program
Start-Up
Initialization Strategies
The Wake-Up Initialized Technique
The Explicit init Function Technique
The Nifty Counter Technique
The Check-Every-Time Technique
Clean-Up
ReviewIII: LOGICAL DESIGN ISSUES
Chapter 8: Architecting a Component
Abstractions and Components
Component Interface Design
Degrees of Encapsulation
Auxiliary Implementation ClassesChapter 9: Designing a Function
Function Interface Specification
Operator or Non-Operator Function
Free or Member Operator
Virtual or Non-Virtual Function
Pure or Non-Pure Virtual Member Function
Static or Non-Static Member Function
const Member or Non-const Member Function
Public, Protected or Private Member Function
Return by Value, Reference or Pointer
Return const or Non-const
Argument Optional or Required
Pass Argument by Value, Reference or Pointer
Pass Argument as const or Non-const
Friend or Non-Friend Function
Inline or Non-Inline Function
Fundamental Types Used in the Interface
Using short in the Interface
Using unsigned in the Interface
Using long in the Interface
Using float, double, and long double in the Interface
Special-Case Functions
Conversion Operators
Compiler-Generated Value Semantics
The DestructorChapter 10: Implementing an Object
Member Data
Natural Alignment
Fundamental Types Used in the Implementation
Using typedef in the Implementation
Function Definitions
AssertYourself!
Avoid Special Casing
FactorInstead of Duplicate
Don't Be Too Clever
Memory Management
Logical versus Physical State Values
Physical Parameters
Memory Allocators
Class-Specific Memory Management
Adding Custom Memory Management
Hogging Memory
Object-Specific Memory Management
Using C++ Templates in Large Projects
Compiler Implementations
Managing Memory in Templates
Patterns versus TemplatesAppendix A: The Protocol Hierarchy
Intent
Also Known As
Motivation
Applicability
Structure
icipants
Collaborations
Consequences
Implementation
Sample Code
Known Uses
Related Patterns
Appendix B: Implementing an ANSI C-Compatible C++ Interface
Memory Allocation Error Detection
Providing a Main Procedure (ANSI C Only)
Appendix C: A Dependency Extractor/Analyzer Package
Using adep, cdep, and ldep
Command-Line Documentation
Idep Package Architecture
Source Code
Appendix D: Quick Reference
Definitions
Major Design Rules
Minor Design Rules
Guidelines
Principles