Muutke küpsiste eelistusi

Professional Cplusplus 2nd Revised edition [Pehme köide]

4.32/5 (189 hinnangut Goodreads-ist)
, ,
  • Formaat: Paperback / softback, 1104 pages, kõrgus x laius x paksus: 235x189x51 mm, kaal: 1824 g, Illustrations
  • Ilmumisaeg: 04-Oct-2011
  • Kirjastus: Wrox Press
  • ISBN-10: 0470932449
  • ISBN-13: 9780470932445
Teised raamatud teemal:
Professional Cplusplus 2nd Revised editionSuurem pilt
  • Formaat: Paperback / softback, 1104 pages, kõrgus x laius x paksus: 235x189x51 mm, kaal: 1824 g, Illustrations
  • Ilmumisaeg: 04-Oct-2011
  • Kirjastus: Wrox Press
  • ISBN-10: 0470932449
  • ISBN-13: 9780470932445
Teised raamatud teemal:
Püsilink: https://www.kriso.ee/db/9780470932445.html
Essential reading for experienced developers who are determined to master the latest release of C++

Although C++ is often the language of choice from game programming to major commercial software applications, it is also one of the most difficult to master. With this no-nonsense book, you will learn to conquer the latest release of C++. An author team of veteran programmers deciphers little-known features of C++, shares detailed code examples that you can then plug into your own code, and reveals the significant changes to C++ that accompany the latest release. You'll discover how to design and build applications that solve real-world problems and then explains how to implement the solution using the full capabilities of the language.

  • Bypasses the basics of C++ and appeals to experienced developers who are looking to for a higher level of learning
  • Drills down the extensive changes to the latest version of C++, including enhancements made to run-time and build-time performance, language usability, and core language
  • Zeroes in on explaining the more poorly understood elements of the C++ feature set and addresses common pitfalls to avoid
  • Includes several case studies that feature extensive, working code that has been tested on Windows, Linux, and Solaris platforms
  • Intertwines text with non-trivial tips, tricks, and workarounds

Packed with best practices for programming, testing, and debugging applications, this book is vital for taking your C++ skills to the next level.

Introduction xxv
Part I: Introduction to Professional C++
Chapter 1 A Crash Course In C++
3(46)
The Basics of C++
3(21)
The Obligatory Hello, World
4(3)
Namespaces
7(1)
Variables
8(3)
Operators
11(2)
Types
13(3)
Conditionals
16(3)
Loops
19(1)
Arrays
20(2)
Functions
22(2)
Those Are the Basics
24(1)
Diving Deeper into C++
24(9)
Pointers and Dynamic Memory
24(4)
Strings in C++
28(1)
References
29(1)
Exceptions
30(1)
The Many Uses of const
31(2)
C++ as an Object-Oriented Language
33(2)
Declaring a Class
33(2)
The Standard Library
35(2)
Your First Useful C++ Program
37(10)
An Employee Records System
37(1)
The Employee Class
37(4)
The Database Class
41(3)
The User Interface
44(3)
Evaluating the Program
47(1)
Summary
47(2)
Chapter 2 Designing Professional C++ Programs
49(28)
What Is Programming Design?
50(1)
The Importance of Programming Design
50(2)
What's Different about C++ Design?
52(1)
Two Rules for C++ Design
53(4)
Abstraction
54(1)
Reuse
55(2)
Reusing Code
57(11)
A Note on Terminology
57(1)
Deciding Whether or Not to Reuse Code
58(2)
Strategies for Reusing Code
60(5)
Bundling Third-Party Applications
65(1)
Open-Source Libraries
66(1)
The C++ Standard Library
67(1)
Designing with Patterns and Techniques
68(1)
Designing a Chess Program
69(6)
Requirements
69(1)
Design Steps
69(6)
Summary
75(2)
Chapter 3 Designing With Objects
77(20)
Am I Thinking Procedurally?
78(1)
The Object-Oriented Philosophy
78(3)
Classes
78(1)
Components
79(1)
Properties
79(1)
Behaviors
80(1)
Bringing It All Together
80(1)
Living in a World of Objects
81(2)
Overobjectification
81(1)
Overly General Objects
82(1)
Object Relationships
83(9)
The Has-A Relationship
83(1)
The Is-A Relationship (Inheritance)
84(2)
The Fine Line between Has-A and Is-A
86(3)
The Not-A Relationship
89(1)
Hierarchies
90(1)
Multiple Inheritance
91(1)
Mix-in Classes
92(1)
Abstraction
92(4)
Interface versus Implementation
93(1)
Deciding on an Exposed Interface
93(2)
Designing a Successful Abstraction
95(1)
Summary
96(1)
Chapter 4 Designing For Reuse
97(14)
The Reuse Philosophy
97(1)
How to Design Reusable Code
98(12)
Use Abstraction
99(1)
Structure Your Code for Optimal Reuse
100(4)
Design Usable Interfaces
104(5)
Reconciling Generality and Ease of Use
109(1)
Summary
110(1)
Chapter 5 Coding With Style
111(22)
The Importance of Looking Good
111(1)
Thinking Ahead
112(1)
Elements of Good Style
112(1)
Documenting Your Code
112(8)
Reasons to Write Comments
112(4)
Commenting Styles
116(4)
Comments in This Book
120(1)
Decomposition
120(2)
Decomposition through Refactoring
121(1)
Decomposition by Design
121(1)
Decomposition in This Book
122(1)
Naming
122(3)
Choosing a Good Name
122(1)
Naming Conventions
123(2)
Using Language Features with Style
125(1)
Use Constants
125(1)
Use References Instead of Pointers
125(1)
Use Custom Exceptions
126(1)
Formatting
126(2)
The Curly Brace Alignment Debate
126(2)
Coming to Blows over Spaces and Parentheses
128(1)
Spaces and Tabs
128(1)
Stylistic Challenges
128(1)
Summary
129(4)
Part II: C++ Coding the Professional Way
Chapter 6 Gaining Proficiency With Classes And Objects
133(36)
Introducing the Spreadsheet Example
134(1)
Writing Classes
134(8)
Class Definitions
134(3)
Defining Methods
137(4)
Using Objects
141(1)
Object Life Cycles
142(25)
Object Creation
143(17)
Object Destruction
160(2)
Assigning to Objects
162(3)
Distinguishing Copying from Assignment
165(2)
Summary
167(2)
Chapter 7 Mastering Classes And Objects
169(42)
Dynamic Memory Allocation in Objects
169(12)
The Spreadsheet Class
170(2)
Freeing Memory with Destructors
172(1)
Handling Copying and Assignment
172(9)
Different Kinds of Data Members
181(5)
static Data Members
181(2)
const Data Members
183(1)
Reference Data Members
184(1)
const Reference Data Members
185(1)
More about Methods
186(6)
static Methods
186(1)
const Methods
186(2)
Method Overloading
188(2)
Default Parameters
190(1)
Inline Methods
191(1)
Nested Classes
192(2)
Enumerated Types Inside Classes
194(1)
Friends
195(2)
Operator Overloading
197(9)
Example: Implementing Addition for SpreadsheetCells
197(5)
Overloading Arithmetic Operators
202(2)
Overloading Comparison Operators
204(2)
Building Types with Operator Overloading
206(1)
Building Stable Interfaces
206(4)
Using Interface and Implementation Classes
206(4)
Summary
210(1)
Chapter 8 Discovering Inheritance Techniques
211(56)
Building Classes with Inheritance
211(8)
Extending Classes
212(3)
Overriding Methods
215(4)
Inheritance for Reuse
219(4)
The WeatherPrediction Class
219(1)
Adding Functionality in a Subclass
220(2)
Replacing Functionality in a Subclass
222(1)
Respect Your Parents
223(7)
Parent Constructors
223(1)
Parent Destructors
224(2)
Referring to Parent Names
226(3)
Casting Up and Down
229(1)
Inheritance for Polymorphism
230(9)
Return of the Spreadsheet
230(1)
Designing the Polymorphic Spreadsheet Cell
231(1)
The Spreadsheet Cell Base Class
231(2)
The Individual Subclasses
233(3)
Leveraging Polymorphism
236(1)
Future Considerations
237(2)
Multiple Inheritance
239(4)
Inheriting from Multiple Classes
239(1)
Naming Collisions and Ambiguous Base Classes
240(3)
Interesting and Obscure Inheritance Issues
243(23)
Changing the Overridden Method's Characteristics
243(4)
Inherited Constructors
247(4)
Special Cases in Overriding Methods
251(7)
Copy Constructors and the Equals Operator in Subclasses
258(1)
The Truth about virtual
259(4)
Run Time Type Facilities
263(1)
Non-Public Inheritance
264(1)
Virtual Base Classes
265(1)
Summary
266(1)
Chapter 9 Understanding C++ Quirks And Oddities
267(50)
References
268(14)
Reference Variables
268(3)
Reference Data Members
271(1)
Reference Parameters
271(2)
Reference Return Values
273(1)
Deciding between References and Pointers
273(4)
Rvalue References
277(5)
Keyword Confusion
282(10)
The const Keyword
282(6)
The static Keyword
288(4)
Order of Initialization of Nonlocal Variables
292(1)
Types and Casts
292(8)
typedefs
292(2)
typedefs for Function Pointers
294(1)
Type Aliases
295(1)
Casts
296(4)
Scope Resolution
300(1)
C++11
301(9)
Uniform Initialization
302(2)
Alternative Function Syntax
304(1)
Null Pointer Constant
304(1)
Angle Brackets
305(1)
Initializer Lists
306(1)
Explicit Conversion Operators
306(2)
Attributes
308(1)
User Defined Literals
308(2)
Header Files
310(2)
C Utilities
312(4)
Variable-Length Argument Lists
312(2)
Preprocessor Macros
314(2)
Summary
316(1)
Chapter 10 Handling Errors
317(44)
Errors and Exceptions
317(3)
What Are Exceptions, Anyway?
318(1)
Why Exceptions in C++ Are a Good Thing
318(2)
Why Exceptions in C++ Are a Bad Thing
320(1)
Our Recommendation
320(1)
Exception Mechanics
320(16)
Throwing and Catching Exceptions
321(3)
Exception Types
324(2)
Throwing and Catching Multiple Exceptions
326(3)
Uncaught Exceptions
329(2)
Throw Lists
331(5)
Exceptions and Polymorphism
336(8)
The Standard Exception Hierarchy
336(1)
Catching Exceptions in a Class Hierarchy
337(2)
Writing Your Own Exception Classes
339(3)
Nested Exceptions
342(2)
Stack Unwinding and Cleanup
344(3)
Use Smart Pointers
346(1)
Catch, Cleanup, and Rethrow
346(1)
Common Error-Handling Issues
347(8)
Memory Allocation Errors
347(3)
Errors in Constructors
350(2)
Function-Try-Blocks for Constructors
352(2)
Errors in Destructors
354(1)
Putting It All Together
355(4)
Summary
359(2)
Chapter 11 Delving Into The Standard Library
361(24)
Coding Principles
362(4)
Use of Templates
362(4)
Use of Operator Overloading
366(1)
Overview of the C++ Standard Library
366(18)
Strings
366(1)
I/O Streams
366(1)
Localization
367(1)
Smart Pointers
367(1)
Exceptions
367(1)
Mathematical Utilities
368(1)
Time Utilities
368(1)
Random Numbers
368(1)
Compile-Time Rational Arithmetic
369(1)
Tuples
369(1)
Regular Expressions
369(1)
The Standard Template Library
369(7)
STL Algorithms
376(8)
What's Missing from the STL
384(1)
Summary
384(1)
Chapter 12 Understanding Containers And Iterators
385(72)
Containers Overview
386(7)
Requirements on Elements
387(1)
Exceptions and Error Checking
388(1)
Iterators
388(3)
C++11 Changes
391(2)
Sequential Containers
393(28)
vector
393(19)
The vector <bool> Specialization
412(1)
deque
413(1)
list
413(5)
array
418(1)
forward_list
418(3)
Container Adapters
421(7)
queue
421(3)
priority_queue
424(3)
stack
427(1)
Associative Containers
428(16)
The pair Utility Class
428(2)
map
430(8)
multimap
438(3)
set
441(3)
multiset
444(1)
Unordered Associative Containers/Hash Tables
444(6)
Hash Functions
444(1)
unordered_map
445(3)
unordered_map Example: Phone Book
448(1)
unordered_multimap
449(1)
unordered_set/unordered_multiset
449(1)
Other Containers
450(6)
Standard C-Style Arrays
450(1)
strings
451(1)
Streams
451(1)
bitset
452(4)
Summary
456(1)
Chapter 13 Mastering STL Algorithms
457(52)
Overview of Algorithms
457(6)
The find and find_if Algorithms
458(3)
The accumulate Algorithms
461(1)
C++11 Move Semantics with Algorithms
462(1)
Lambda Expressions
463(6)
Syntax
463(2)
Capture Block
465(1)
Lambda Expressions as Return Type
465(2)
Lambda Expressions as Parameters
467(1)
Examples
467(2)
Function Objects
469(12)
Arithmetic Function Objects
470(1)
Comparison Function Objects
471(1)
Logical Function Objects
472(1)
Bitwise Function Objects
473(1)
Function Object Adapters
473(7)
Writing Your Own Function Objects
480(1)
Algorithm Details
481(22)
Utility Algorithms
482(1)
Non-Modifying Algorithms
483(7)
Modifying Algorithms
490(9)
Sorting Algorithms
499(2)
Set Algorithms
501(2)
Algorithms Example: Auditing Voter Registrations
503(4)
The Voter Registration Audit Problem Statement
503(1)
The auditVoterRolls Function
504(1)
The getDuplicates Function
505(1)
Testing the auditVoterRolls Function
506(1)
Summary
507(2)
Chapter 14 Using Strings And Regular Expressions
509(36)
Dynamic Strings
510(7)
C-Style Strings
510(2)
String Literals
512(1)
The C++ string Class
513(3)
Raw String Literals
516(1)
Localization
517(6)
Localizing String Literals
518(1)
Wide Characters
518(1)
Non-Western Character Sets
519(2)
Locales and Facets
521(2)
Regular Expressions
523(20)
ECMAScript Syntax
524(6)
The regex Library
530(1)
regex_match()
531(3)
regex_search()
534(2)
regex_iterator
536(1)
regex_token_iterator
537(3)
regex_replace()
540(3)
Summary
543(2)
Chapter 15 Demystifying C++ I/O
545(24)
Using Streams
546(14)
What Is a Stream, Anyway?
546(1)
Stream Sources and Destinations
547(1)
Output with Streams
547(5)
Input with Streams
552(7)
Input and Output with Objects
559(1)
String Streams
560(2)
File Streams
562(4)
Jumping around with seek() and tell()
563(2)
Linking Streams Together
565(1)
Bidirectional I/O
566(1)
Summary
567(2)
Chapter 16 Additional Library Utilities
569(26)
std::function
569(2)
Ratios
571(3)
The Chrono Library
574(7)
Duration
574(4)
Clock
578(2)
Time Point
580(1)
Random Number Generation
581(9)
Random Number Engines
582(2)
Random Number Engine Adapters
584(1)
Predefined Engines and Engine Adapters
584(1)
Generating Random Numbers
585(2)
Random Number Distributions
587(3)
Tuples
590(4)
Summary
594(1)
Chapter 17 Customizing And Extending The STL
595(50)
Allocators
596(1)
Iterator Adapters
596(6)
Reverse Iterators
596(2)
Stream Iterators
598(1)
Insert Iterators
599(1)
Move Iterators
600(2)
Extending the STL
602(39)
Why Extend the STL?
602(1)
Writing an STL Algorithm
602(3)
Writing an STL Container
605(36)
Summary
641(4)
Part III: Mastering Advanced Features of C++
Chapter 18 Overloading C++ Operators
645(38)
Overview of Operator Overloading
646(8)
Why Overload Operators?
646(1)
Limitations to Operator Overloading
646(1)
Choices in Operator Overloading
647(2)
Operators You Shouldn't Overload
649(1)
Summary of Overloadable Operators
650(3)
Rvalue References
653(1)
Overloading the Arithmetic Operators
654(2)
Overloading Unary Minus and Unary Plus
654(1)
Overloading Increment and Decrement
655(1)
Overloading the Bitwise and Binary Logical Operators
656(1)
Overloading the Insertion and Extraction Operators
657(2)
Overloading the Subscripting Operator
659(5)
Providing Read-Only Access with operator[ ]
662(1)
Non-Integral Array Indices
663(1)
Overloading the Function Call Operator
664(2)
Overloading the Dereferencing Operators
666(3)
Implementing operator*
667(1)
Implementing operator->
668(1)
What in the World Is operator ->*?
669(1)
Writing Conversion Operators
669(6)
Ambiguity Problems with Conversion Operators
671(1)
Conversions for Boolean Expressions
672(3)
Overloading the Memory Allocation and Deallocation Operators
675(7)
How new and delete Really Work
675(2)
Overloading operator new and operator delete
677(2)
Overloading operator new and operator delete with Extra Parameters
679(2)
Explicitly Deleting/Defaulting operator new and operator delete
681(1)
Summary
682(1)
Chapter 19 Writing Generic Code With Templates
683(32)
Overview of Templates
684(1)
Class Templates
684(26)
Writing a Class Template
685(8)
How the Compiler Processes Templates
693(1)
Distributing Template Code between Files
694(1)
Template Parameters
695(3)
Method Templates
698(5)
Template Class Specialization
703(3)
Subclassing Template Classes
706(2)
Inheritance versus Specialization
708(1)
Template Aliases
708(1)
Alternative Function Syntax
709(1)
Function Templates
710(4)
Function Template Specialization
711(1)
Function Template Overloading
712(1)
Friend Function Templates of Class Templates
713(1)
Summary
714(1)
Chapter 20 Advanced Templates
715(44)
More about Template Parameters
715(9)
More about Template Type Parameters
715(4)
Introducing Template Template Parameters
719(2)
More about Non-Type Template Parameters
721(3)
Template Class Partial Specialization
724(5)
Another Form of Partial Specialization
726(3)
Emulating Function Partial Specialization with Overloading
729(2)
More on Deduction
730(1)
Template Recursion
731(7)
An N-Dimensional Grid: First Attempt
731(2)
A Real N-Dimensional Grid
733(5)
Type Inference
738(4)
The auto Keyword
738(1)
The decltype Keyword
739(1)
auto and decltype with Templates
739(3)
Variadic Templates
742(4)
Type-Safe Variable-Length Argument Lists
743(2)
Variable Number of Mix-In Classes
745(1)
Metaprogramming
746(11)
Factorial at Compile Time
746(1)
Loop Unrolling
747(2)
Printing Tuples
749(2)
Type Traits
751(6)
Conclusion
757(1)
Summary
757(2)
Chapter 21 Effective Memory Management
759(38)
Working with Dynamic Memory
759(12)
How to Picture Memory
760(1)
Allocation and Deallocation
761(2)
Arrays
763(6)
Working with Pointers
769(2)
Array-Pointer Duality
771(3)
Arrays Are Pointers!
772(1)
Not All Pointers Are Arrays!
773(1)
Low-Level Memory Operations
774(5)
Pointer Arithmetic
774(1)
Custom Memory Management
775(1)
Garbage Collection
775(1)
Object Pools
776(1)
Function Pointers
776(2)
Pointers to Methods and Members
778(1)
Smart Pointers
779(11)
The Old Deprecated auto_ptr
780(1)
The New C++11 Smart Pointers
781(3)
Writing Your Own Smart Pointer Class
784(6)
Common Memory Pitfalls
790(6)
Underallocating Strings
790(1)
Memory Leaks
791(3)
Double-Deleting and Invalid Pointers
794(1)
Accessing Out-of-Bounds Memory
795(1)
Summary
796(1)
Chapter 22 Multithreaded Programming With C++
797(42)
Introduction
798(4)
Race Conditions and Deadlocks
799(3)
Atomic Operations Library
802(4)
Atomic Type Example
803(2)
Atomic Operations
805(1)
Threads
806(9)
Thread with Function Pointer
806(2)
Thread with Function Object
808(2)
Thread with Lambda
810(1)
Thread with Member Function
811(1)
Thread Local Storage
811(1)
Cancelling Threads
812(1)
Retrieving Results from Threads
812(1)
Copying and Rethrowing Exceptions
812(3)
Mutual Exclusion
815(8)
Mutex Classes
815(2)
Locks
817(2)
std::call_once
819(1)
Mutex Usage Examples
820(3)
Condition Variables
823(2)
Futures
825(2)
Example: Multithreaded Logger Class
827(6)
Thread Pools
833(1)
Threading Design and Best Practices
834(1)
Summary
835(4)
Part IV: C++ Software Engineering
Chapter 23 Maximizing Software Engineering Methods
839(20)
The Need for Process
840(1)
Software Life Cycle Models
841(6)
The Stagewise Model and Waterfall Model
841(2)
The Spiral Model
843(2)
The Rational Unified Process
845(2)
Software Engineering Methodologies
847(7)
Agile
847(1)
Scrum
848(2)
Extreme Programming (XP)
850(4)
Software Triage
854(1)
Building Your Own Process and Methodology
854(1)
Be Open to New Ideas
854(1)
Bring New Ideas to the Table
855(1)
Recognize What Works and What Doesn't Work
855(1)
Don't Be a Renegade
855(1)
Source Code Control
855(2)
Summary
857(2)
Chapter 24 Writing Efficient C++
859(24)
Overview of Performance and Efficiency
859(2)
Two Approaches to Efficiency
860(1)
Two Kinds of Programs
860(1)
Is C++ an Inefficient Language?
860(1)
Language-Level Efficiency
861(5)
Handle Objects Efficiently
862(4)
Use Inline Methods and Functions
866(1)
Design-Level Efficiency
866(5)
Cache as Much as Possible
866(1)
Use Object Pools
867(4)
Profiling
871(11)
Profiling Example with gprof
872(8)
Profiling Example with Visual C++ 2010
880(2)
Summary
882(1)
Chapter 25 Developing Cross-Platform And Cross-Language Applications
883(22)
Cross-Platform Development
884(4)
Architecture Issues
884(2)
Implementation Issues
886(2)
Platform-Specific Features
888(1)
Cross-Language Development
888(15)
Mixing C and C++
889(1)
Shifting Paradigms
889(3)
Linking with C Code
892(2)
Mixing C# with C++
894(2)
Mixing Java and C++ with JNI
896(2)
Mixing C++ with Perl and Shell Scripts
898(4)
Mixing C++ with Assembly Code
902(1)
Summary
903(2)
Chapter 26 Becoming Adept At Testing
905(22)
Quality Control
906(3)
Whose Responsibility Is Testing?
906(1)
The Life Cycle of a Bug
906(1)
Bug-Tracking Tools
907(2)
Unit Testing
909(12)
Approaches to Unit Testing
909(1)
The Unit Testing Process
910(4)
Unit Testing in Action
914(7)
Higher-Level Testing
921(3)
Integration Tests
921(2)
System Tests
923(1)
Regression Tests
923(1)
Tips for Successful Testing
924(1)
Summary
925(2)
Chapter 27 Conquering Debugging
927(40)
The Fundamental Law of Debugging
928(1)
Bug Taxonomies
928(1)
Avoiding Bugs
928(1)
Planning for Bugs
929(16)
Error Logging
929(1)
Debug Traces
930(13)
Asserts
943(1)
Static Asserts
944(1)
Debugging Techniques
945(21)
Reproducing Bugs
945(1)
Debugging Reproducible Bugs
946(1)
Debugging Non reproducible Bugs
947(1)
Debugging Memory Problems
948(4)
Debugging Multithreaded Programs
952(1)
Debugging Example: Article Citations
953(13)
Lessons from the Article Citations Example
966(1)
Summary
966(1)
Chapter 28 Incorporating Design Techniques And Frameworks
967(18)
"I Can Never Remember How to..."
968(5)
... Write a Class
968(1)
... Subclass an Existing Class
969(1)
... Throw and Catch Exceptions
970(1)
... Read from a File
971(1)
... Write to a File
971(1)
... Write a Template Class
972(1)
There Must Be a Better Way
973(8)
Double Dispatch
973(6)
Mix-In Classes
979(2)
Object-Oriented Frameworks
981(2)
Working with Frameworks
982(1)
The Model-View-Controller Paradigm
982(1)
Summary
983(2)
Chapter 29 Applying Design Patterns
985(28)
The Iterator Pattern
986(1)
The Singleton Pattern
987(8)
Example: A Logging Mechanism
987(1)
Implementation of a Singleton
987(4)
Using a Singleton
991(1)
Singletons and Multithreading
992(3)
The Factory Pattern
995(5)
Example: A Car Factory Simulation
995(1)
Implementation of a Factory
996(2)
Using a Factory
998(2)
Other Uses of Factories
1000(1)
The Proxy Pattern
1000(2)
Example: Hiding Network Connectivity Issues
1000(1)
Implementation of a Proxy
1001(1)
Using a Proxy
1002(1)
The Adapter Pattern
1002(2)
Example: Adapting a Logger Class
1002(1)
Implementation of an Adapter
1003(1)
Using an Adapter
1004(1)
The Decorator Pattern
1004(3)
Example: Defining Styles in Web Pages
1004(1)
Implementation of a Decorator
1005(1)
Using a Decorator
1006(1)
The Chain of Responsibility Pattern
1007(2)
Example: Event Handling
1008(1)
Implementation of a Chain of Responsibility
1008(1)
Using a Chain of Responsibility
1009(1)
The Observer Pattern
1009(3)
Example: Event Handling
1009(1)
Implementation of an Observer
1009(2)
Using an Observer
1011(1)
Summary
1012(1)
Appendix A: C++ Interviews 1013(22)
Appendix B: Annotated Bibliography 1035(10)
Appendix C: Standard Library Header Files 1045(8)
Index 1053
Marc Gregoire is a Microsoft Visual C++ MVP, an active contributor to CodeGuru, and blogs at www.nuonsoft.com/blog/. Marc is a software architect, worked for Siemens and Nokia Siemens Networks as a software consultant, and now works for Nikon Metrology. Nicholas A. Solter is an application architect at ContextOptional, Inc., a social media advertising company. Scott J. Kleper is cofounder and CTO of ContextOptional, Inc.