book

Beautiful C++: 30 Core Guidelines for Writing Clean, Safe, and Fast Code

Name: Beautiful C++: 30 Core Guidelines for Writing Clean, Safe, and Fast Code
ISBN: 9780137647767

by J. Guy Davidson, Kate Gregory

December 2021

Intermediate to advanced

352 pages

9h 32m

English

Addison-Wesley Professional

Read now

Unlock full access

Cover Page
About This eBook
Halftitle Page
Title Page
Copyright Page
Humans are born to learn
Contents
Selected C++ Core Guidelines
Foreword
Preface
About This BookAccess the Code

Acknowledgments
About the Authors
Section 1: Bikeshedding is bad
Chapter 1.1. P.2: Write in ISO Standard C++
What is ISO Standard C++?Encapsulating variationsLearning the old waysStaying on top of developments to the standard
Chapter 1.2. F.51: Where there is a choice, prefer default arguments over overloading
IntroductionRefining your abstraction: Additional arguments or overloading?The subtleties of overload resolutionBack to the exampleThe unambiguous nature of default argumentsAlternatives to overloadingSometimes you must overloadSummary
Chapter 1.3. C.45: Don’t define a default constructor that only initializes data members; use in-class member initializers instead
Why have default constructors anyway?How do you initialize a data member?What happens when two people maintain a class?Summary
Chapter 1.4. C.131: Avoid trivial getters and setters
An archaic idiomAbstractionMere EncapsulationClass InvariantsNouns and VerbsSummary
Chapter 1.5. ES.10: Declare one name (only) per declaration
Let me introduce youBackward compatibilityWriting clearer declarationsStructured bindingSummary
Chapter 1.6. NR.2: Don’t insist to have only a single return-statement in a function
Rules evolveEnsuring cleanupUsing RAIIWriting good functionsSummary
Section 2: Don’t hurt yourself
Chapter 2.1. P.11: Encapsulate messy constructs, rather than spreading through the code
All in one gulpWhat it means to encapsulate a messy constructThe purpose of language and the nature of abstractionLevels of abstractionAbstraction by refactoring and drawing the lineSummary
Chapter 2.2. I.23: Keep the number of function arguments low
How much should they earn?Simplifying matters through abstractionDo as little as possible, but no lessReal-life examplesSummary
Chapter 2.3. I.26: If you want a cross-compiler ABI, use a C-style subset
Creating librariesWhat is an ABI?Paring back to the absolute minimumException propagationSummary
Chapter 2.4. C.47: Define and initialize member variables in the order of member declaration
Summary
Chapter 2.5. CP.3: Minimize explicit sharing of writable data
Traditional execution modelWait, there’s moreAvoiding deadlocks and data racesSetting aside locks and mutexesSummary
Chapter 2.6. T.120: Use template metaprogramming only when you really need to
std::enable_if => requiresSummary
Section 3: Stop using that
Chapter 3.1. I.11: Never transfer ownership by a raw pointer (T*) or reference (T&)
Using the free storeThe performance cost of smart pointersUsing unadorned reference semanticsgsl::ownerSummary
Chapter 3.2. I.3: Avoid singletons
Global objects are badSingleton Design PatternStatic initialization order fiascoHow to hide a singletonBut only one of these should ever existWait a moment…Summary
Chapter 3.3. C.90: Rely on constructors and assignment operators, not memset and memcpy
Chasing maximum performanceThe horrendous overhead of the constructorThe simplest possible classWhat is the standard talking about anyway?But what about memcpy?Never underestimate the compilerSummary
Chapter 3.4. ES.50: Don’t cast away const
Story timeDealing with rather more dataThe const firewallImplementing a dual interfaceCaching and lazy evaluationTwo types of constSurprises with constSummary
Chapter 3.5. E.28: Avoid error handling based on global state (e.g. errno)
Error handling is hardC and errnoReturn codesExceptions<system_error>Boost.OutcomeWhy is error handling so hard?Light at the end of the tunnelSummary
Chapter 3.6. SF.7: Don’t write using namespace at global scope in a header file
Don’t do thisDisambiguationUsing usingWhere do the symbols go?An altogether more insidious problemSolving the problem of cluttered scope resolution operatorsThe temptation and The FallSummary
Section 4: Use this new thing properly
Chapter 4.1. F.21: To return multiple “out” values, prefer returning a struct or tuple
The shape of a function signatureDocumenting and annotatingNow you can return an objectYou can also return a tuplePassing and returning by non-const referenceSummary
Chapter 4.2. Enum.3: Prefer class enums over “plain” enums
ConstantsScoped enumerationsUnderlying typeImplicit conversionSummaryPostscript
Chapter 4.3. ES.5: Keep scopes small
The nature of scopeBlock scopeNamespace scopeClass scopeFunction parameter scopeEnumeration scopeTemplate parameter scopeScope as contextSummary
Chapter 4.4. Con.5: Use constexpr for values that can be computed at compile time
From const to constexprDefault C++Using constexprinlineconstevalconstinitSummary
Chapter 4.5. T.1: Use templates to raise the level of abstraction of code
Story timeRaising the level of abstractionFunction templates and abstractionClass templates and abstractionNaming is hardSummary
Chapter 4.6. T.10: Specify concepts for all template arguments
How did we get here?Constraining your parametersHow to abstract your conceptsFactoring via conceptsSummary
Section 5: Write code well by default
Chapter 5.1. P.4: Ideally, a program should be statically type safe
Type safety is a security feature of C++UnionCastingUnsignedBuffers and sizesSummary
Chapter 5.2. P.10: Prefer immutable data to mutable data
The wrong defaultsconstness in function declarationsSummary
Chapter 5.3. I.30: Encapsulate rule violations
Hiding the unsightly things in lifeKeeping up appearancesSummary
Chapter 5.4. ES.22: Don’t declare a variable until you have a value to initialize it with
The importance of expressions and statementsC-style declarationDeclare-then-initializeMaximally delayed declarationLocalization of context-specific functionalityEliminating stateSummary
Chapter 5.5. Per.7: Design to enable optimization
Maximizing the frame rateWorking further from the metalOptimization through abstractionSummary
Chapter 5.6. E.6: Use RAII to prevent leaks
Deterministic destructionLeaking away filesWhy are we bothering?This all seems a bit much: Future possibilitiesWhere can I get this?
Envoi
Afterword
Index
Code Snippets

Content preview from Beautiful C++: 30 Core Guidelines for Writing Clean, Safe, and Fast Code

Chapter 4.1

F.21: To return multiple “out” values, prefer returning a struct or tuple

The shape of a function signature

When we learn about functions, we learn about taking arguments, manipulating these inputs, and returning a value, an output. A function can take as many argu-ments as you like, but it can only return one thing.

This can cause problems. How do you signal an error condition? As discussed elsewhere, this problem remains without satisfactory resolution, but one historically popular approach is to take an error argument and write to that, while returning the result.

This gives us two kinds of function argument: input parameters and output parameters. The input parameters are used in the evaluation of the function, while the output ...

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

C++ Core Guidelines Explained: Best Practices for Modern C++

Publisher Resources

ISBN: 9780137647767

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Beautiful C++: 30 Core Guidelines for Writing Clean, Safe, and Fast Code

by J. Guy Davidson, Kate Gregory

Chapter 4.1