book

More Exceptional C++

Name: More Exceptional C++
Author: Herb Sutter
ISBN: 020170434X

by Herb Sutter

December 2001

Intermediate to advanced

304 pages

6h 25m

English

Addison-Wesley Professional

Read now

Unlock full access

Copyright
Dedication
Foreword
Preface
What's “More?”What I Assume You KnowHow to Read This BookNamespaces, Typename, References, and Other ConventionsAcknowledgments
Generic Programming and the C++ Standard Library
1. Switching Streams
SolutionThe Tersest SolutionToward More-Flexible SolutionsMethod A: Templates (Compile-Time Polymorphism)Method B: Virtual Functions (Run-Time Polymorphism)Sound Engineering Principles
2. Predicates, Part 1: What remove() Removes
SolutionWhat remove() Removes
3. Predicates, Part 2: Matters of State
SolutionUnary and Binary PredicatesThe Next Step: Stateful PredicatesFollow-Up Question
4. Extensible Templates: Via Inheritance or Traits?
SolutionRequiring Member FunctionsConstraints ClassesRequiring Inheritance, Take 1: IsDerivedFrom1 Value HelperRequiring Inheritance, Take 2: IsDerivedFrom2 Constraints Base ClassRequiring Inheritance, Take 3: A Merged IsDerivedFromSelecting Alternative ImplementationsRequirements versus TraitsInheritance versus Traits
5. Typename
Solution1. Use typename for Dependent Names2. The Secondary (and Subtle) PointPostscript
6. Containers, Pointers, and Containers That Aren't
SolutionPreludeWhy Take Pointers or References into Containers?How Could the Code Be Improved?When Is a Container Not a Container?Which Brings Us to the Awkward PartThe Life and Times of vector<bool>Proxied Containers and STL AssumptionsBeware Premature OptimizationSo What Should You Do?

7. Using vector and deque
SolutionUsing a vector as an Array: A Motivating ExampleA Fly in the Ointment?In Most Cases, Prefer Using vectorThe Incredible Shrinking vectorSummary
8. Using set and map
SolutionAssociative Containers: ReviewThe Key RequirementA Motivating ExampleOption #1: Say “const Means const!” (Insufficient)Option #2: Say “Always Change Keys Using Erase-Then-Insert” (Better, But Still Insufficient)What About set?The Key Requirement (Reprise)
9. Equivalent Code?
Solution1. A macro.2. A function.3. An object.4. A type name.1. A macro.2. An object (possibly of a built-in type).3. A value, such as an address.Some Effects of Side EffectsScissors, Traffic, and Iterators
10. Template Specialization and Overloading
SolutionExplicit SpecializationPartial SpecializationFunction Template Overloading
11. Mastermind
Simplified Rules SummarySolutionSolution #1ChoosePegCountPlaceCountColorSummarySolution #2CombinationColorMatchSummaryComparing the Solutions
Optimization and Performance
12. inline
SolutionJust Say “No for Now”What About Computation-Intensive Tasks (Such as Numeric Libraries)?What About Accessors?
13. Lazy Optimization, Part 1: A Plain Old String
SolutionImplementing Original::StringAside: What's the Best Buffer Growth Strategy?
14. Lazy Optimization, Part 2: Introducing Laziness
Solution
15. Lazy Optimization, Part 3: Iterators and References
SolutionWriting operator[] for Shareable StringsKey Notion: An “Unshareable” StringSummary
16. Lazy Optimization, Part 4: Multithreaded Environments
SolutionThread-Safety Problems with Copy-on-Write (COW)Protecting COW StringsSome Empirical ResultsSummary
Exception Safety Issues and Techniques
17. Constructor Failures, Part 1: Object Lifetimes
SolutionFunction Try BlocksObject Lifetimes and What a Constructor Exception Means
18. Constructor Failures, Part 2: Absorption?
SolutionI Can't Keep No Caught ExceptionsA Step Toward MoralityAside: Why Does C++ Do It That Way?Morals About Function Try BlocksMorals About Safe CodingThat's Just the Way It IsA Final Word: Failure-Proof Constructors?Summary
19. Uncaught Exceptions
SolutionRecapping uncaught_exception()Background: The Problem with Throwing DestructorsThe Wrong SolutionWhy the Wrong Solution Is UnsoundWhy the Wrong Solution Is ImmoralThe Right Solution
20. An Unmanaged Pointer Problem, Part 1: Parameter Evaluation
SolutionRecap: Evaluation Orders and DisordersSome Function Call Exception Safety Problems
21. An Unmanaged Pointer Problem, Part 2: What About auto_ptr?
SolutionAside: A Non-SolutionA Limited SolutionGeneralizing the auto_ptr_new() SolutionA Better SolutionSummaryAcknowledgments
22. Exception-Safe Class Design, Part 1: Copy Assignment
SolutionReview: Exception Safety Canonical FormsAnalyzing the Cargill Widget ExampleA General Technique: Using the Pimpl IdiomA Potential Objection, and Why It's UnreasonableConclusion 1: Exception Safety Affects a Class's DesignConclusion 2: You Can Always Make Your Code (Nearly) Strongly Exception-SafeConclusion 3: Use Pointers Judiciously
23. Exception-Safe Class Design, Part 2: Inheritance
SolutionIs-Implemented-In-Terms-OfHow to Implement IIITO: Inheritance or Delegation?Exception Safety ConsequencesSummary
Inheritance and Polymorphism
24. Why Multiple Inheritance?
Solution
25. Emulating Multiple Inheritance
SolutionDrawbacks
26. Multiple Inheritance and the Siamese Twin Problem
SolutionHow to Separate Siamese Twins
27. (Im)pure Virtual Functions
Solution1. Pure Virtual Destructor2. Force Conscious Acceptance of Default Behavior3. Provide Partial Behavior4. Work Around Poor Compiler Diagnostics
28. Controlled Polymorphism
Solution
Memory and Resource Management
29. Using auto_ptr
SolutionProblem: Arrays and auto_ptr Don't MixAside on a Non-problem: Zero-Length Arrays Are OkayOption 1: Roll Your Own auto_arrayOption 1 (a): … By Deriving from auto_ptr (Score: 0 / 10)Option 1 (b): … By Cloning auto_ptr Code (Score: 8 / 10)Option 2: Use the Adapter Pattern (Score: 7 / 10)Option 3: Replace auto_ptr with Hand-Coded Exception-Handling Logic (Score: 1 / 10 )Option 4: Use a vector Instead of an Array (Score: 9.5 / 10 )
30. Smart Pointer Members, Part 1: A Problem with auto_ptr
SolutionRecap: Problems of Pointer MembersWhat About auto_ptr Members?Variations on a Theme by ValuePtr
31. Smart Pointer Members, Part 2: Toward a ValuePtr
SolutionA Simple ValuePtr: Strict Ownership OnlyCopy Construction and Copy AssignmentTemplated Construction and Templated AssignmentAdding Extensibility Using TraitsApplying TraitsValuePtr with TraitsA Usage ExampleSummary
Free Functions and Macros
32. Recursive Declarations
SolutionFunction Pointers: RecapA Brief Look at State MachinesHow Can a Function Return a Pointer to Itself?A Correct and Portable WayCoda
33. Simulating Nested Functions
SolutionRecap: Nested and Local ClassesNested Functions: OverviewAttempts at Simulating Nested Functions in C++A Somewhat Improved SolutionA Complete SolutionSummary
34. Preprocessor Macros
Solution1. Header Guards2. Accessing Preprocessor Features3. Selecting Code at Compile Time (or Build-Specific Code)a) Debug Codeb) Platform-Specific Codec) Variant Data Representations
35. #Definition
SolutionCommon Macro Pitfalls1. Don't forget to put parentheses around arguments.2. Don't forget to put parentheses around the whole expansion.3. Watch for multiple argument evaluation.4. Name tromping.Other Macro Drawbacks5. Macros can't recurse.6. Macros don't have addresses.7. Macros are debugger-unfriendly.There Are Some Things Even a Macro Won't Do
Miscellaneous Topics
36. Initialization
Solution
37. Forward Declarations
Solution
38. Typedef
SolutionTypedef: Controlling What's in a NameTypeabilityReadabilityCommunicationPortabilityFlexibilityTraitabilitySummary
39. Namespaces, Part 1: Using-Declarations and Using-Directives
SolutionUsing-DeclarationsUsing-Directives
40. Namespaces, Part 2: Migrating to Namespaces
SolutionMigrating to Namespaces, Safely and EffectivelyGuidelines for a Good Long-Term SolutionNamespace Rule #1: Never write using-directives in header files.Namespace Rule #2: Never write namespace using-declarations in header files.Namespace Rule #3: In implementation files, never write a using-declaration or a using-directive before an #include directive.“Kinda Sorta” Namespace Rule #4: Use C headers with the new style #include <cheader> instead of the old style #include <header.h>.Long-Term Approaches: A Motivating ExampleA Good Long-Term SolutionA Not-So-Good Long-Term SolutionAn Effective Short-Term SolutionMigration Step #1: In every header file, add “std::” qualifiers wherever needed.Migration Step #2: Create a new header file called myproject_last.h that contains the directive using namespace std;. In every implementation file, #include myproject_last.h after all other #includes.Conclusion: Migrating to the Long-Term Solution
Afterword
A. Optimizations That Aren't (in a Multithreaded World)
IntroductionWhat's the Fuss About?Recap: Plain Old Original:: String (Item 13)Using a Plain Old String: Single-ThreadedUsing a Plain Old String: MultithreadedNow Throw in an “Optimization”: Copy-On-Write (COW)Using a COW String: MultithreadedMild versus Severe InefficienciesSome Actual NumbersA Real-World Example: C++'s basic_string“Am I Affected?”Summary
B. Test Results for Single-Threaded versus Multithread-Safe String Implementations
ApproachRaw MeasurementsTesting Const Copying and Destruction: The Target Case of CowTesting Append(): An Always-Mutating Periodically-Reallocating OperationTesting Operator[](): A Possibly-Mutating Operation, Never Does MutateTesting Various Integer Increment/Decrement OperationsTest Harness
Bibliography

Content preview from More Exceptional C++

Part . Exception Safety Issues and Techniques

It's pretty near impossible to write robust code in modern C++ without knowing about exception safety issues. Period.

If you use the C++ standard library, including even just new, you have to be prepared for exceptions. This section builds on the corresponding section of Exceptional C++ and considers new issues and techniques, such as, What's std:: uncaught_exception(), and does it help you to write more-robust code? Does exception safety affect a class's design, or can it just be retrofitted as an afterthought? Why use manager objects to encapsulate resource ownership, and why is the “resource acquisition is initialization” idiom so important for writing safe code?

But first, let's get our feet wet ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Boost C++ Application Development Cookbook - Second Edition

Publisher Resources

ISBN: 020170434XPurchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

More Exceptional C++

by Herb Sutter

Part . Exception Safety Issues and Techniques

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.