book

100 C++ Mistakes and How to Avoid Them

Name: 100 C++ Mistakes and How to Avoid Them
Author: Rich Yonts
ISBN: 9781633436893

by Rich Yonts

January 2025

Intermediate to advanced

360 pages

10h 19m

English

Manning Publications

Read now

Unlock full access

100 C++ Mistakes and How to Avoid Them
Copyright
contents
front matter
prefaceacknowledgmentsabout this bookWho should read this bookHow this book is organized: A road mapAbout the codeliveBook discussion forumabout the authorabout the cover illustration
1 C++: With great power comes great responsibility
1.1 Mistakes1.1.1 A quick example1.2 Anatomy of a mistake1.2.1 Correctness1.2.2 Readability1.2.3 Effectiveness1.2.4 Performance1.3 Learning from our mistakes1.3.1 Noticing mistakes1.3.2 Understanding mistakes1.3.3 Fixing mistakes1.3.4 Learning from mistakes1.4 Where we’ll find mistakes1.4.1 Class design1.4.2 Program implementation1.4.3 Library problems1.4.4 Modern C++1.4.5 Old standards and usage1.4.6 Lost expertise and misguided training1.5 A word about organizationSummary
Part 1. Modern C++
2 Better modern C++: Classes and types
2.1 Mistake 1: Failing to use move semantics2.2 Mistake 2: Using empty exception specifications2.3 Mistake 3: Not using override on derived virtual functions2.4 Mistake 4: Writing simple or hiding unwanted supplied class members2.5 Mistake 5: Not using in-class initializers2.6 Mistake 6: Overusing index-based loops2.7 Mistake 7: Failing to use nullptr2.8 Mistake 8: Not using unique_ptrs for exclusive ownership2.9 Mistake 9: Not using shared_ptrs for shared ownership
3 Better modern C++: General programming
3.1 Mistake 10: Failing to use if with initialization3.2 Mistake 11: Not using type inference for variables3.3 Mistake 12: Using typedef3.4 Mistake 13: Writing common algorithms3.5 Mistake 14: Not using uniform initialization3.6 Mistake 15: Failing to use emplacement3.7 Mistake 16: Failing to use tuples3.8 Mistake 17: Not using structured binding
4 Better modern C++: Additional topics
4.1 Mistake 18: Not using variadic templates4.2 Mistake 19: Using global namespace enums4.3 Mistake 20: Not using new formatting functionality4.4 Mistake 21: Not using ranges with containers4.5 Mistake 22: Writing nonportable filesystem code4.6 Mistake 23: Writing excessive standalone functions4.7 Mistake 24: Using awkward constants4.8 Mistake 25: Writing pattern-matching code
Part 2. Transitional C++

5 C idioms
5.1 Mistake 26: Always declaring variables at the top of a function5.2 Mistake 27: Depending on macros5.3 Mistake 28: Misunderstanding NULL5.4 Mistake 29: Accessing disk files using FILE5.5 Mistake 30: Using integers for Boolean values5.6 Mistake 31: Using C-style casts5.7 Mistake 32: Converting text with atoi5.8 Mistake 33: Using C-style strings5.9 Mistake 34: Calling the exit function5.10 Mistake 35: Preferring arrays to vectors
6 Better premodern C++
6.1 Mistake 36: Input and output using scanf and printf6.2 Mistake 37: Overusing endl6.3 Mistake 38: Dynamic allocation with malloc and free6.4 Mistake 39: Using unions for type conversion6.5 Mistake 40: Using varargs for variable parameter lists6.6 Mistake 41: Incorrect class initialization order6.7 Mistake 42: Adding nonvalue types to containers6.8 Mistake 43: Favoring indexes over iterators
Part 3. Classic (premodern) C++
7 Establishing the class invariant
7.1 Class invariants enforce proper class design7.1.1 Interpretation7.1.2 Set of operations7.1.3 Range of values7.1.4 Memory mechanics7.1.5 Performance implications7.2 Mistakes in class design7.2.1 The class invariant7.2.2 Establishing the class invariant7.3 Mistake 44: Failing to maintain the class invariant7.4 Mistake 45: Not thinking of classes as data types7.5 Mistake 46: Not establishing a basis for methods7.6 Mistake 47: Failing to code the big 37.7 Mistake 48: Using inheritance just for code reuse7.8 Mistake 49: Overusing default constructors7.9 Mistake 50: Failing to maintain the is-a relationship
8 Maintaining the class invariant
8.1 Maintaining the class invariant8.2 Mistake 51: Writing nonessential accessors8.3 Mistake 52: Providing trivial mutators8.4 Mistake 53: Overusing protected instance variables8.5 Mistake 54: Mistaking operator= and copy constructor semantics8.6 Mistake 55: Misunderstanding shallow and deep copy semantics8.7 Mistake 56: Failing to call base class operators8.8 Mistake 57: Failing to use virtual destructors in polymorphic base classes8.9 Mistake 58: Calling virtual functions in constructors and destructors8.10 Mistake 59: Attempting to use polymorphic array elements8.11 Mistake 60: Failing to initialize all instance variables
9 Class operations
9.1 Mistake 61: Misunderstanding variable shadowing9.2 Mistake 62: Allowing duplication of unique objects9.3 Mistake 63: Not coding for return value optimization9.4 Mistake 64: Not returning a reference from copy assignment operators9.5 Mistake 65: Forgetting to handle self-assignment9.6 Mistake 66: Misunderstanding prefix and postfix forms9.7 Mistake 67: Misleading implicit conversion operators9.8 Mistake 68: Overusing implicit conversion constructors9.9 Mistake 69: Focusing too much on standalone operators9.10 Mistake 70: Failing to mark nonmutating methods constant9.11 Mistake 71: Not properly marking class methods static9.12 Mistake 72: Incorrectly choosing between member and nonmember functions9.13 Mistake 73: Incorrectly returning strings from accessor methods
10 Exceptions and resources
10.1 Using exceptions10.1.1 Affirmation: Intermixed control and recovery paths10.1.2 Objection: Confusing exception handling with normal error handling10.1.3 Objection: Difficulty retrofitting exception handling10.1.4 Affirmation: Ambiguous values10.1.5 Affirmation: Ambiguous data types10.1.6 Affirmation: Enforcing error handling10.1.7 Objection: Providing recovery handlers10.1.8 Affirmation: Transforming failure types10.1.9 Affirmation: Separation of concerns10.1.10 Objection: Encouraging upfront design10.2 Mistake 74: Not throwing exceptions from constructors10.3 Mistake 75: Throwing exceptions from destructors10.4 Mistake 76: Allowing resource leaks when using exceptions10.5 Mistake 77: Failing to use the RAII pattern10.6 Mistake 78: Using raw pointers to resources10.7 Mistake 79: Mixing new and delete forms10.8 Mistake 80: Trusting exception specifications10.9 Mistake 81: Failing to throw by value and catch by reference
11 Functions and coding
11.1 Design considerations11.2 Mistake 82: Using overloaded functions instead of parameter defaulting11.3 Mistake 83: Failing to use assertions11.4 Mistake 84: Returning pointers or references to local objects11.5 Mistake 85: Using output parameters11.6 Mistake 86: Incorrect use of parameter types11.7 Mistake 87: Depending on parameter evaluation order11.8 Mistake 88: Passing excessive parameters11.9 Mistake 89: Overly long functions with multiple behaviors11.10 Mistake 90: Overly responsible functions
12 General coding
12.1 Mistake 91: Improperly handling division by zero12.2 Mistake 92: Incorrectly using the continue keyword in loops12.3 Mistake 93: Failing to set deleted pointers to NULL12.4 Mistake 94: Failing to return directly computed Boolean values12.5 Mistake 95: Underusing expressions12.6 Mistake 96: Using extraneous else keywords12.7 Mistake 97: Not using helper functions12.8 Mistake 98: Wrongly comparing floating-point values12.9 Mistake 99: Floating-point to integer assignment12.10 Mistake 100: Ignoring compiler warnings
index

Overview

Learn how to handle errors, inefficiencies, and outdated paradigms by exploring the most common mistakes you’ll find in production C++ code.

100 C++ Mistakes and How To Avoid Them reveals the problems you’ll inevitably encounter as you write new C++ code and diagnose legacy applications, along with practical techniques you need to resolve them.

Inside 100 C++ Mistakes and How To Avoid Them you’ll learn how to:

Design solid classes
Minimize resource allocation/deallocation issues
Use new C++ features
Identify the differences between compile and runtime issues
Recognize C-style idioms that miss C++ functionality
Use exceptions well

100 C++ Mistakes and How To Avoid Them gives you practical insights and techniques to improve your C++ coding kung fu. Author Rich Yonts has been using C++ since its invention in the 1980s. This book distills that experience into practical, reusable advice on how C++ programmers at any skill level can improve their code. Unlike many C++ books that concentrate on language theory and toy exercises, this book is loaded with real examples from production codebases.

About the Technology
Over ten billion lines of C++ code are running in production applications, and 98-developers find and fix mistakes in them every day. Even mission-critical applications have bugs, performance inefficiencies, and readability problems. This book will help you identify them in the code you’re maintaining and avoid them in the code you’re writing.

About the Book
100 C++ Mistakes and How To Avoid Them presents practical techniques to improve C++ code, from legacy applications to modern codebases that use C++ 11 and beyond. Author Rich Yonts provides a concrete example to illustrate each issue, along with a step-by-step walkthrough for improving readability, effectiveness, and performance. Along the way, you’ll even learn how and where to replace outdated patterns and idioms with modern C++.

What's Inside

Design solid classes
Resource allocation/deallocation issues
Compile and runtime problems
Replace C-style idioms with proper C++

About the Reader
Covers C++ 98 through 23, with an emphasis on diagnosing and improving legacy code.

About the Author
Rich Yonts is a Senior Software Engineer at Teradata and a long-time software engineer using C++, Java, and Python. He has held a number of technical and leadership roles during his many years at IBM and Sony.

Quotes
A comprehensive collection of common pitfalls providing clear examples and practical advice on how to avoid them. An invaluable resource!
- Yacob Cohen-Arazi, NVIDIA

Examples were excellent, explained with in-depth detail that you can apply to your C++ projects!
- Stanley Anozie, Santander Consumer Bank AG

Methodical and practical! Addresses challenges faced by developers working with legacy codebases with clear, actionable solutions that bridge the gap between classical and modern C++.
- Matt Godbolt, Aquatic Capital Management

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

Publisher Resources

ISBN: 9781633436893Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills