Professional C++ (Second Edition)

Cover
Professional C++ (Second Edition)
Copyright
Contents
Introduction
Part I: Introduction to Professional C++
	Chapter 1: A Crash Course in C++
		The Basics of C++
			The Obligatory Hello, World
			Namespaces
			Variables
			Operators
			Types
			Conditionals
			Loops
			Arrays
			Functions
			Those Are the Basics
		Diving Deeper into C++
			Pointers and Dynamic Memory
			Strings in C++
			References
			Exceptions
			The Many Uses of const
		C++ as an Object- Oriented Language
			Declaring a Class
		The Standard Library
		Your First Useful C++ Program
			An Employee Records System
			The Employee Class
			The Database Class
			The User Interface
			Evaluating the Program
		Summary
	Chapter 2: Designing Professional C++ Programs
		What Is Programming Design?
		The Importance of Programming Design
		What\'s Different about C++ Design?
		Two Rules for C++ Design
			Abstraction
			Reuse
		Reusing Code
			A Note on Terminology
			Deciding Whether or Not to Reuse Code
			Strategies for Reusing Code
			Bundling Third-Party Applications
			Open-Source Libraries
			The C++ Standard Library
		Designing with Patterns and Techniques
		Designing a Chess Program
			Requirements
			Design Steps
		Summary
	Chapter 3: Designing With Objects
		Am I Thinking Procedurally?
		The Object-Oriented Philosophy
			Classes
			Components
			Properties
			Behaviors
			Bringing It All Together
		Living in a World of Objects
			Overobjectification
			Overly General Objects
		Object Relationships
			The Has-A Relationship
			The Is-A Relationship (Inheritance)
			The Fine Line between Has-A and Is-A
			The Not-A Relationship
			Hierarchies
			Multiple Inheritance
			Mix-in Classes
		Abstraction
			Interface versus Implementation
			Deciding on an Exposed Interface
			Designing a Successful Abstraction
		Summary
	Chapter 4: Designing for Reuse
		The Reuse Philosophy
		How to Design Reusable Code
			Use Abstraction
			Structure Your Code for Optimal Reuse
			Design Usable Interfaces
			Reconciling Generality and Ease of Use
		Summary
	Chapter 5: Coding with Style
		The Importance of Looking Good
			Thinking Ahead
			Elements of Good Style
		Documenting Your Code
			Reasons to Write Comments
			Commenting Styles
			Comments in This Book
		Decomposition
			Decomposition through Refactoring
			Decomposition by Design
			Decomposition in This Book
		Naming
			Choosing a Good Name
			Naming Conventions
		Using Language Features with Style
			Use Constants
			Use References Instead of Pointers
			Use Custom Exceptions
		Formatting
			The Curly Brace Alignment Debate
			Coming to Blows over Spaces and Parentheses
			Spaces and Tabs
		Stylistic Challenges
		Summary
Part II: C++ Coding the Professional Way
	Chapter 6: Gaining Proficiency with Classes and Objects
		Introducing the Spreadsheet Example
		Writing Classes
			Class Definitions
			Defining Methods
			Using Objects
		Object Life Cycles
			Object Creation
			Object Destruction
			Assigning to Objects
			Distinguishing Copying from Assignment
		Summary
	Chapter 7: mastering classes and Objects
		Dynamic Memory Allocation in Objects
			The Spreadsheet Class
			Freeing Memory with Destructors
			Handling Copying and Assignment
		Different Kinds of Data Members
			static Data Members
			const Data Members
			Reference Data Members
			const Reference Data Members
		More about Methods
			static Methods
			const Methods
			Method Overloading
			Default Parameters
			Inline Methods
		Nested Classes
		Enumerated Types Inside Classes
		Friends
		Operator Overloading
			Example: Implementing Addition for SpreadsheetCells
			Overloading Arithmetic Operators
			Overloading Comparison Operators
			Building Types with Operator Overloading
		Building Stable Interfaces
			Using Interface and Implementation Classes
		Summary
	Chapter 8: Discovering Inheritance Techniques
		Building Classes with Inheritance
			Extending Classes
			Overriding Methods
		Inheritance for Reuse
			The WeatherPrediction Class
			Adding Functionality in a Subclass
			Replacing Functionality in a Subclass
		Respect Your Parents
			Parent Constructors
			Parent Destructors
			Referring to Parent Names
			Casting Up and Down
		Inheritance for Polymorphism
			Return of the Spreadsheet
			Designing the Polymorphic Spreadsheet Cell
			The Spreadsheet Cell Base Class
			The Individual Subclasses
			Leveraging Polymorphism
			Future Considerations
		Multiple Inheritance
			Inheriting from Multiple Classes
			Naming Collisions and Ambiguous Base Classes
		Interesting and Obscure Inheritance Issues
			Changing the Overridden Method\'s Characteristics
			Inherited Constructors
			Special Cases in Overriding Methods
			Copy Constructors and the Equals Operator in Subclasses
			The Truth about virtual
			Run Time Type Facilities
			Non-Public Inheritance
			Virtual Base Classes
		Summary
	Chapter 9: Understanding C++ Quirks and Oddities
		References
			Reference Variables
			Reference Data Members
			Reference Parameters
			Reference Return Values
			Deciding between References and Pointers
			Rvalue References
		Keyword Confusion
			The const Keyword
			The static Keyword
			Order of Initialization of Nonlocal Variables
		Types and Casts
			typedefs
			typedefs for Function Pointers
			Type Aliases
			Casts
		Scope Resolution
		C++11
			Uniform Initialization
			Alternative Function Syntax
			Null Pointer Constant
			Angle Brackets
			Initializer Lists
			Explicit Conversion Operators
			Attributes
			User Defined Literals
		Header Files
		C Utilities
			Variable-Length Argument Lists
			Preprocessor Macros
		Summary
	Chapter 10: Handling Errors
		Errors and Exceptions
			What Are Exceptions, Anyway?
			Why Exceptions in C++ Are a Good Thing
			Why Exceptions in C++ Are a Bad Thing
			Our Recommendation
		Exception Mechanics
			Throwing and Catching Exceptions
			Exception Types
			Throwing and Catching Multiple Exceptions
			Uncaught Exceptions
			Throw Lists
		Exceptions and Polymorphism
			The Standard Exception Hierarchy
			Catching Exceptions in a Class Hierarchy
			Writing Your Own Exception Classes
			Nested Exceptions
		Stack Unwinding and Cleanup
			Use Smart Pointers
			Catch, Cleanup, and Rethrow
		Common Error-Handling Issues
			Memory Allocation Errors
			Errors in Constructors
			Function-Try-Blocks for Constructors
			Errors in Destructors
		Putting It All Together
		Summary
	Chapter 11: Delving into the Standard Library
		Coding Principles
			Use of Templates
			Use of Operator Overloading
		Overview of the C++ Standard Library
			Strings
			I/O Streams
			Localization
			Smart Pointers
			Exceptions
			Mathematical Utilities
			Time Utilities
			Random Numbers
			Compile-Time Rational Arithmetic
			Tuples
			Regular Expressions
			The Standard Template Library
			STL Algorithms
			What\'s Missing from the STL
		Summary
	Chapter 12: Understanding Containers and Iterators
		Containers Overview
			Requirements on Elements
			Exceptions and Error Checking
			Iterators
			C++11 Changes
		Sequential Containers
			vector
			The vector Specialization
			deque
			list
			array
			forward_list
		Container Adapters
			queue
			priority_queue
			stack
		Associative Containers
			The pair Utility Class
			map
			multimap
			set
			multiset
		Unordered Associative Containers/Hash Tables
			Hash Functions
			unordered_map
			unordered_map Example: Phone Book
			unordered_multimap
			unordered_set/unordered_multiset
		Other Containers
			Standard C-Style Arrays
			strings
			Streams
			bitset
		Summary
	Chapter 13: Mastering STL Algorithms
		Overview of Algorithms
			The find and find_if Algorithms
			The accumulate Algorithms
			C++11 Move Semantics with Algorithms
		Lambda Expressions
			Syntax
			Capture Block
			Lambda Expressions as Return Type
			Lambda Expressions as Parameters
			Examples
		Function Objects
			Arithmetic Function Objects
			Comparison Function Objects
			Logical Function Objects
			Bitwise Function Objects
			Function Object Adapters
			Writing Your Own Function Objects
		Algorithm Details
			Utility Algorithms
			Non-Modifying Algorithms
			Modifying Algorithms
			Sorting Algorithms
			Set Algorithms
		Algorithms Example: Auditing Voter Registrations
			The Voter Registration Audit Problem Statement
			The auditVoterRolls Function
			The getDuplicates Function
			Testing the auditVoterRolls Function
		Summary
	Chapter 14: Using Strings and Regular Expressions
		Dynamic Strings
			C-Style Strings
			String Literals
			The C++ string Class
			Raw String Literals
		Localization
			Localizing String Literals
			Wide Characters
			Non-Western Character Sets
			Locales and Facets
		Regular Expressions
			ECMAScript Syntax
			The regex Library
			regex_match()
			regex_search()
			regex_iterator
			regex_token_iterator
			regex_replace()
		Summary
	Chapter 15: Demystifying C++ I/ O
		Using Streams
			What Is a Stream, Anyway?
			Stream Sources and Destinations
			Output with Streams
			Input with Streams
			Input and Output with Objects
		String Streams
		File Streams
			Jumping around with seek() and tell()
			Linking Streams Together
		Bidirectional I/O
		Summary
	Chapter 16: Additional Library Utilities
		std::function
		Ratios
		The Chrono Library
			Duration
			Clock
			Time Point
		Random Number Generation
			Random Number Engines
			Random Number Engine Adapters
			Predefined Engines and Engine Adapters
			Generating Random Numbers
			Random Number Distributions
		Tuples
		Summary
	Chapter 17: Customizing and Extending the STL
		Allocators
		Iterator Adapters
			Reverse Iterators
			Stream Iterators
			Insert Iterators
			Move Iterators
		Extending the STL
			Why Extend the STL?
			Writing an STL Algorithm
			Writing an STL Container
		Summary
Part III: Mastering Advanced Features of C++
	Chapter 18: Overloading C++ Operators
		Overview of Operator Overloading
			Why Overload Operators?
			Limitations to Operator Overloading
			Choices in Operator Overloading
			Operators You Shouldn\'t Overload
			Summary of Overloadable Operators
			Rvalue References
		Overloading the Arithmetic Operators
			Overloading Unary Minus and Unary Plus
			Overloading Increment and Decrement
		Overloading the Bitwise and Binary Logical Operators
		Overloading the Insertion and Extraction Operators
		Overloading the Subscripting Operator
			Providing Read-Only Access with operator[]
			Non-Integral Array Indices
		Overloading the Function Call Operator
		Overloading the Dereferencing Operators
			Implementing operator*
			Implementing operator->
			What in the World Is operator ->* ?
		Writing Conversion Operators
			Ambiguity Problems with Conversion Operators
			Conversions for Boolean Expressions
		Overloading the Memory Allocation and Deallocation Operators
			How new and delete Really Work
			Overloading operator new and operator delete
			Overloading operator new and operator delete with Extra Parameters
			Explicitly Deleting/ Defaulting operator new and operator delete
		Summary
	Chapter 19: Writing Generic Code with Templates
		Overview of Templates
		Class Templates
			Writing a Class Template
			How the Compiler Processes Templates
			Distributing Template Code between Files
			Template Parameters
			Method Templates
			Template Class Specialization
			Subclassing Template Classes
			Inheritance versus Specialization
			Template Aliases
			Alternative Function Syntax
		Function Templates
			Function Template Specialization
			Function Template Overloading
			Friend Function Templates of Class Templates
		Summary
	Chapter 20: Advanced Templates
		More about Template Parameters
			More about Template Type Parameters
			Introducing Template Template Parameters
			More about Non-Type Template Parameters
		Template Class Partial Specialization
			Another Form of Partial Specialization
		Emulating Function Partial Specialization with Overloading
			More on Deduction
		Template Recursion
			An N-Dimensional Grid: First Attempt
			A Real N-Dimensional Grid
		Type Inference
			The auto Keyword
			The decltype Keyword
			auto and decltype with Templates
		Variadic Templates
			Type-Safe Variable-Length Argument Lists
			Variable Number of Mix-In Classes
		Metaprogramming
			Factorial at Compile Time
			Loop Unrolling
			Printing Tuples
			Type Traits
			Conclusion
		Summary
	Chapter 21: Effective Memory Management
		Working with Dynamic Memory
			How to Picture Memory
			Allocation and Deallocation
			Arrays
			Working with Pointers
		Array-Pointer Duality
			Arrays Are Pointers!
			Not All Pointers Are Arrays!
		Low-Level Memory Operations
			Pointer Arithmetic
			Custom Memory Management
			Garbage Collection
			Object Pools
			Function Pointers
			Pointers to Methods and Members
		Smart Pointers
			The Old Deprecated auto_ptr
			The New C++11 Smart Pointers
			Writing Your Own Smart Pointer Class
		Common Memory Pitfalls
			Underallocating Strings
			Memory Leaks
			Double-Deleting and Invalid Pointers
			Accessing Out-of-Bounds Memory
		Summary
	Chapter 22: Multithreaded Programming with C++
		Introduction
			Race Conditions and Deadlocks
		Atomic Operations Library
			Atomic Type Example
			Atomic Operations
		Threads
			Thread with Function Pointer
			Thread with Function Object
			Thread with Lambda
			Thread with Member Function
			Thread Local Storage
			Cancelling Threads
			Retrieving Results from Threads
			Copying and Rethrowing Exceptions
		Mutual Exclusion
			Mutex Classes
			Locks
			std::call_once
			Mutex Usage Examples
		Condition Variables
		Futures
		Example: Multithreaded Logger Class
		Thread Pools
		Threading Design and Best Practices
		Summary
Part IV: C++ Software Engineering
	Chapter 23: Maximizing Software Engineering Methods
		The Need for Process
		Software Life Cycle Models
			The Stagewise Model and Waterfall Model
			The Spiral Model
			The Rational Unified Process
		Software Engineering Methodologies
			Agile
			Scrum
			Extreme Programming (XP)
			Software Triage
		Building Your Own Process and Methodology
			Be Open to New Ideas
			Bring New Ideas to the Table
			Recognize What Works and What Doesn\'t Work
			Don\'t Be a Renegade
		Source Code Control
		Summary
	Chapter 24: Writing Efficient C++
		Overview of Performance and Efficiency
			Two Approaches to Efficiency
			Two Kinds of Programs
			Is C++ an Inefficient Language?
		Language-Level Efficiency
			Handle Objects Efficiently
			Use Inline Methods and Functions
		Design-Level Efficiency
			Cache as Much as Possible
			Use Object Pools
		Profiling
			Profiling Example with gprof
			Profiling Example with Visual C++ 2010
		Summary
	Chapter 25: Developing Cross-Platform and Cross-Language Applications
		Cross-Platform Development
			Architecture Issues
			Implementation Issues
			Platform-Specific Features
		Cross-Language Development
			Mixing C and C++
			Shifting Paradigms
			Linking with C Code
			Mixing C# with C++
			Mixing Java and C++ with JNI
			Mixing C++ with Perl and Shell Scripts
			Mixing C++ with Assembly Code
		Summary
	Chapter 26: Becoming Adept at Testing
		Quality Control
			Whose Responsibility Is Testing?
			The Life Cycle of a Bug
			Bug-Tracking Tools
		Unit Testing
			Approaches to Unit Testing
			The Unit Testing Process
			Unit Testing in Action
		Higher-Level Testing
			Integration Tests
			System Tests
			Regression Tests
		Tips for Successful Testing
		Summary
	Chapter 27: Conquering Debugging
		The Fundamental Law of Debugging
		Bug Taxonomies
		Avoiding Bugs
		Planning for Bugs
			Error Logging
			Debug Traces
			Asserts
			Static Asserts
		Debugging Techniques
			Reproducing Bugs
			Debugging Reproducible Bugs
			Debugging Nonreproducible Bugs
			Debugging Memory Problems
			Debugging Multithreaded Programs
			Debugging Example: Article Citations
			Lessons from the ArticleCitations Example
		Summary
	Chapter 28: Incorporating Design Techniques and Frameworks
		\" I Can Never Remember How to . . .\"
			. . . Write a Class
			. . . Subclass an Existing Class
			. . . Throw and Catch Exceptions
			. . . Read from a File
			. . . Write to a File
			. . . Write a Template Class
		There Must Be a Better Way
			Double Dispatch
			Mix-In Classes
		Object-Oriented Frameworks
			Working with Frameworks
			The Model-View-Controller Paradigm
		Summary
	Chapter 29: Applying Design Patterns
		The Iterator Pattern
		The Singleton Pattern
			Example: A Logging Mechanism
			Implementation of a Singleton
			Using a Singleton
			Singletons and Multithreading
		The Factory Pattern
			Example: A Car Factory Simulation
			Implementation of a Factory
			Using a Factory
			Other Uses of Factories
		The Proxy Pattern
			Example: Hiding Network Connectivity Issues
			Implementation of a Proxy
			Using a Proxy
		The Adapter Pattern
			Example: Adapting a Logger Class
			Implementation of an Adapter
			Using an Adapter
		The Decorator Pattern
			Example: Defining Styles in Web Pages
			Implementation of a Decorator
			Using a Decorator
		The Chain of Responsibility Pattern
			Example: Event Handling
			Implementation of a Chain of Responsibility
			Using a Chain of Responsibility
		The Observer Pattern
			Example: Event Handling
			Implementation of an Observer
			Using an Observer
		Summary
Appendix A: C++ Interviews
Appendix B: Annotated Bibliography
Appendix C: Standard Library Header Files
Index