COVER
TITLE PAGE
COPYRIGHT
DEDICATION
ABOUT THE AUTHOR
ABOUT THE TECHNICAL EDITORS
ACKNOWLEDGMENTS
INTRODUCTION
1. WHO THIS BOOK IS FOR
2. WHAT THIS BOOK COVERS
3. HOW THIS BOOK IS STRUCTURED
4. CONVENTIONS
5. WHAT YOU NEED TO USE THIS BOOK
6. READER SUPPORT FOR THIS BOOK
PART I: Introduction to Professional C++
1. 1 A Crash Course in C++ and the Standard Library
  1. C++ CRASH COURSE
  2. YOUR FIRST BIGGER C++ PROGRAM
  3. SUMMARY
  4. EXERCISES
  5. Notes
2. 2 Working with Strings and String Views
  1. DYNAMIC STRINGS
  2. STRING FORMATTING
  3. SUMMARY
  4. EXERCISES
  5. Notes
3. 3 Coding with Style
  1. THE IMPORTANCE OF LOOKING GOOD
  2. DOCUMENTING YOUR CODE
  3. DECOMPOSITION
  4. NAMING
  5. USING LANGUAGE FEATURES WITH STYLE
  6. FORMATTING
  7. STYLISTIC CHALLENGES
  8. SUMMARY
  9. EXERCISES
  10. Notes
PART II: Professional C++ Software Design
1. 4 Designing Professional C++ Programs
  1. WHAT IS PROGRAMMING DESIGN?
  2. THE IMPORTANCE OF PROGRAMMING DESIGN
  3. DESIGNING FOR C++
  4. TWO RULES FOR YOUR OWN C++ DESIGNS
  5. REUSING EXISTING CODE
  6. DESIGNING A CHESS PROGRAM
  7. SUMMARY
  8. EXERCISES
2. 5 Designing with Objects
  1. AM I THINKING PROCEDURALLY?
  2. THE OBJECT-ORIENTED PHILOSOPHY
  3. LIVING IN A WORLD OF CLASSES
  4. CLASS RELATIONSHIPS
  5. SUMMARY
  6. EXERCISES
3. 6 Designing for Reuse
  1. THE REUSE PHILOSOPHY
  2. HOW TO DESIGN REUSABLE CODE
  3. SUMMARY
  4. EXERCISES
PART III: C++ Coding the Professional Way
1. 7 Memory Management
  1. WORKING WITH DYNAMIC MEMORY
  2. ARRAY-POINTER DUALITY
  3. LOW-LEVEL MEMORY OPERATIONS
  4. COMMON MEMORY PITFALLS
  5. SMART POINTERS
  6. SUMMARY
  7. EXERCISES
  8. Notes
2. 8 Gaining Proficiency with Classes and Objects
  1. INTRODUCING THE SPREADSHEET EXAMPLE
  2. WRITING CLASSES
  3. UNDERSTANDING OBJECT LIFE CYCLES
  4. SUMMARY
  5. EXERCISES
  6. Notes
3. 9 Mastering Classes and Objects
  1. FRIENDS
  2. DYNAMIC MEMORY ALLOCATION IN OBJECTS
  3. MORE ABOUT METHODS
  4. DIFFERENT KINDS OF DATA MEMBERS
  5. NESTED CLASSES
  6. ENUMERATED TYPES INSIDE CLASSES
  7. OPERATOR OVERLOADING
  8. BUILDING STABLE INTERFACES
  9. SUMMARY
  10. EXERCISES
4. 10 Discovering Inheritance Techniques
  1. BUILDING CLASSES WITH INHERITANCE
  2. INHERITANCE FOR REUSE
  3. RESPECT YOUR PARENTS
  4. INHERITANCE FOR POLYMORPHISM
  5. MULTIPLE INHERITANCE
  6. INTERESTING AND OBSCURE INHERITANCE ISSUES
  7. CASTS
  8. SUMMARY
  9. EXERCISES
5. 11 Odds and Ends
  1. MODULES
  2. HEADER FILES
  3. FEATURE TEST MACROS FOR CORE LANGUAGE FEATURES
  4. THE STATIC KEYWORD
  5. C UTILITIES
  6. SUMMARY
  7. EXERCISES
6. 12 Writing Generic Code with Templates
  1. OVERVIEW OF TEMPLATES
  2. CLASS TEMPLATES
  3. FUNCTION TEMPLATES
  4. VARIABLE TEMPLATES
  5. CONCEPTS
  6. SUMMARY
  7. EXERCISES
7. 13 Demystifying C++ I/O
  1. USING STREAMS
  2. STRING STREAMS
  3. FILE STREAMS
  4. BIDIRECTIONAL I/O
  5. FILESYSTEM SUPPORT LIBRARY
  6. SUMMARY
  7. EXERCISES
8. 14 Handling Errors
  1. ERRORS AND EXCEPTIONS
  2. EXCEPTION MECHANICS
  3. EXCEPTIONS AND POLYMORPHISM
  4. RETHROWING EXCEPTIONS
  5. STACK UNWINDING AND CLEANUP
  6. COMMON ERROR-HANDLING ISSUES
  7. SUMMARY
  8. EXERCISES
9. 15 Overloading C++ Operators
  1. OVERVIEW OF OPERATOR OVERLOADING
  2. OVERLOADING THE ARITHMETIC OPERATORS
  3. OVERLOADING THE BITWISE AND BINARY LOGICAL OPERATORS
  4. OVERLOADING THE INSERTION AND EXTRACTION OPERATORS
  5. OVERLOADING THE SUBSCRIPTING OPERATOR
  6. OVERLOADING THE FUNCTION CALL OPERATOR
  7. OVERLOADING THE DEREFERENCING OPERATORS
  8. WRITING CONVERSION OPERATORS
  9. OVERLOADING THE MEMORY ALLOCATION AND DEALLOCATION OPERATORS
  10. OVERLOADING USER-DEFINED LITERAL OPERATORS
  11. SUMMARY
  12. EXERCISES
10. 16 Overview of the C++ Standard Library
  1. CODING PRINCIPLES
  2. OVERVIEW OF THE C++ STANDARD LIBRARY
  3. SUMMARY
  4. EXERCISES
11. 17 Understanding Iterators and the Ranges Library
  1. ITERATORS
  2. STREAM ITERATORS
  3. ITERATOR ADAPTERS
  4. RANGES
  5. SUMMARY
  6. EXERCISES
12. 18 Standard Library Containers
  1. CONTAINERS OVERVIEW
  2. SEQUENTIAL CONTAINERS
  3. CONTAINER ADAPTERS
  4. ORDERED ASSOCIATIVE CONTAINERS
  5. UNORDERED ASSOCIATIVE CONTAINERS OR HASH TABLES
  6. OTHER CONTAINERS
  7. SUMMARY
  8. EXERCISES
13. 19 Function Pointers, Function Objects, and Lambda Expressions
  1. FUNCTION POINTERS
  2. POINTERS TO METHODS (AND DATA MEMBERS)
  3. std::function
  4. FUNCTION OBJECTS
  5. LAMBDA EXPRESSIONS
  6. INVOKERS
  7. SUMMARY
  8. EXERCISES
14. 20 Mastering Standard Library Algorithms
  1. OVERVIEW OF ALGORITHMS
  2. ALGORITHM DETAILS
  3. SUMMARY
  4. EXERCISES
15. 21 String Localization and Regular Expressions
  1. LOCALIZATION
  2. REGULAR EXPRESSIONS
  3. SUMMARY
  4. EXERCISES
16. 22 Date and Time Utilities
  1. COMPILE-TIME RATIONAL NUMBERS
  2. DURATION
  3. CLOCK
  4. TIME POINT
  5. DATE
  6. TIME ZONE
  7. SUMMARY
  8. EXERCISES
17. 23 Random Number Facilities
  1. C-STYLE RANDOM NUMBER GENERATION
  2. RANDOM NUMBER ENGINES
  3. RANDOM NUMBER ENGINE ADAPTERS
  4. PREDEFINED ENGINES AND ENGINE ADAPTERS
  5. GENERATING RANDOM NUMBERS
  6. RANDOM NUMBER DISTRIBUTIONS
  7. SUMMARY
  8. EXERCISES
18. 24 Additional Library Utilities
  1. VOCABULARY TYPES
  2. TUPLES
  3. SUMMARY
  4. EXERCISES
PART IV: Mastering Advanced Features of C++
1. 25 Customizing and Extending the Standard Library
  1. ALLOCATORS
  2. EXTENDING THE STANDARD LIBRARY
  3. SUMMARY
  4. EXERCISES
  5. Notes
2. 26 Advanced Templates
  1. MORE ABOUT TEMPLATE PARAMETERS
  2. CLASS TEMPLATE PARTIAL SPECIALIZATION
  3. EMULATING FUNCTION PARTIAL SPECIALIZATION WITH OVERLOADING
  4. TEMPLATE RECURSION
  5. VARIADIC TEMPLATES
  6. METAPROGRAMMING
  7. SUMMARY
  8. EXERCISES
3. 27 Multithreaded Programming with C++
  1. INTRODUCTION
  2. THREADS
  3. ATOMIC OPERATIONS LIBRARY
  4. MUTUAL EXCLUSION
  5. CONDITION VARIABLES
  6. LATCHES
  7. BARRIERS
  8. SEMAPHORES
  9. FUTURES
  10. EXAMPLE: MULTITHREADED LOGGER CLASS
  11. THREAD POOLS
  12. COROUTINES
  13. THREADING DESIGN AND BEST PRACTICES
  14. SUMMARY
  15. EXERCISES
PART V: C++ Software Engineering
1. 28 Maximizing Software Engineering Methods
  1. THE NEED FOR PROCESS
  2. SOFTWARE LIFE CYCLE MODELS
  3. SOFTWARE ENGINEERING METHODOLOGIES
  4. BUILDING YOUR OWN PROCESS AND METHODOLOGY
  5. SOURCE CODE CONTROL
  6. SUMMARY
  7. EXERCISES
2. 29 Writing Efficient C++
  1. OVERVIEW OF PERFORMANCE AND EFFICIENCY
  2. LANGUAGE-LEVEL EFFICIENCY
  3. DESIGN-LEVEL EFFICIENCY
  4. PROFILING
  5. SUMMARY
  6. EXERCISES
3. 30 Becoming Adept at Testing
  1. QUALITY CONTROL
  2. UNIT TESTING
  3. FUZZ TESTING
  4. HIGHER-LEVEL TESTING
  5. TIPS FOR SUCCESSFUL TESTING
  6. SUMMARY
  7. EXERCISES
4. 31 Conquering Debugging
  1. THE FUNDAMENTAL LAW OF DEBUGGING
  2. BUG TAXONOMIES
  3. AVOIDING BUGS
  4. PLANNING FOR BUGS
  5. DEBUGGING TECHNIQUES
  6. SUMMARY
  7. EXERCISES
5. 32 Incorporating Design Techniques and Frameworks
  1. “I CAN NEVER REMEMBER HOW TO…”
  2. THERE MUST BE A BETTER WAY
  3. OBJECT-ORIENTED FRAMEWORKS
  4. SUMMARY
  5. EXERCISES
6. 33 Applying Design Patterns
  1. DEPENDENCY INJECTION
  2. THE ABSTRACT FACTORY PATTERN
  3. THE FACTORY METHOD PATTERN
  4. THE ADAPTER PATTERN
  5. THE PROXY PATTERN
  6. THE ITERATOR PATTERN
  7. THE OBSERVER PATTERN
  8. THE DECORATOR PATTERN
  9. THE CHAIN OF RESPONSIBILITY PATTERN
  10. THE SINGLETON PATTERN
  11. SUMMARY
  12. EXERCISES
7. 34 Developing Cross-Platform and Cross-Language Applications
  1. CROSS-PLATFORM DEVELOPMENT
  2. CROSS-LANGUAGE DEVELOPMENT
  3. SUMMARY
  4. EXERCISES
PART VI: Appendices
1. A C++ Interviews
  1. CHAPTER 1: A CRASH COURSE IN C++ AND THE STANDARD LIBRARY
  2. CHAPTERS 2 AND 21: WORKING WITH STRINGS AND STRING VIEWS, STRING LOCALIZATION AND REGULAR EXPRESSIONS
  3. CHAPTER 3: CODING WITH STYLE
  4. CHAPTER 4: DESIGNING PROFESSIONAL C++ PROGRAMS
  5. CHAPTER 5: DESIGNING WITH OBJECTS
  6. CHAPTER 6: DESIGNING FOR REUSE
  7. CHAPTER 7: MEMORY MANAGEMENT
  8. CHAPTERS 8 AND 9: GAINING PROFICIENCY WITH CLASSES AND OBJECTS, AND MASTERING CLASSES AND OBJECTS
  9. CHAPTER 10: DISCOVERING INHERITANCE TECHNIQUES
  10. CHAPTER 11: ODDS AND ENDS
  11. CHAPTERS 12 AND 26: WRITING GENERIC CODE WITH TEMPLATES, AND ADVANCED TEMPLATES
  12. CHAPTER 13: DEMYSTIFYING C++ I/O
  13. CHAPTER 14: HANDLING ERRORS
  14. CHAPTER 15: OVERLOADING C++ OPERATORS
  15. CHAPTERS 16–20 AND 25: THE STANDARD LIBRARY
  16. CHAPTER 22: DATE AND TIME UTILITIES
  17. CHAPTER 23: RANDOM NUMBER FACILITIES
  18. CHAPTER 24: ADDITIONAL LIBRARY UTILITIES
  19. CHAPTER 27: MULTITHREADED PROGRAMMING WITH C++
  20. CHAPTER 28: MAXIMIZING SOFTWARE ENGINEERING METHODS
  21. CHAPTER 29: WRITING EFFICIENT C++
  22. CHAPTER 30: BECOMING ADEPT AT TESTING
  23. CHAPTER 31: CONQUERING DEBUGGING
  24. CHAPTER 32: INCORPORATING DESIGN TECHNIQUES AND FRAMEWORKS
  25. CHAPTER 33: APPLYING DESIGN PATTERNS
  26. CHAPTER 34: DEVELOPING CROSS-PLATFORM AND CROSS-LANGUAGE APPLICATIONS
2. B Annotated Bibliography
  1. C++
  2. UNIFIED MODELING LANGUAGE
  3. ALGORITHMS AND DATA STRUCTURES
  4. RANDOM NUMBERS
  5. OPEN-SOURCE SOFTWARE
  6. SOFTWARE ENGINEERING METHODOLOGY
  7. PROGRAMMING STYLE
  8. COMPUTER ARCHITECTURE
  9. EFFICIENCY
  10. TESTING
  11. DEBUGGING
  12. DESIGN PATTERNS
  13. OPERATING SYSTEMS
  14. MULTITHREADED PROGRAMMING
3. C Standard Library Header Files
  1. THE C STANDARD LIBRARY
  2. CONTAINERS
  3. ALGORITHMS, ITERATORS, RANGES, AND ALLOCATORS
  4. GENERAL UTILITIES
  5. MATHEMATICAL UTILITIES
  6. EXCEPTIONS
  7. I/O STREAMS
  8. THREADING SUPPORT LIBRARY
4. D Introduction to UML
  1. DIAGRAM TYPES
  2. CLASS DIAGRAMS
  3. INTERACTION DIAGRAMS
INDEX
END USER LICENSE AGREEMENT

List of Illustrations

Chapter 1
1. FIGURE 1-1
2. FIGURE 1-2
3. FIGURE 1-3
Chapter 2
1. FIGURE 2-1
Chapter 3
1. FIGURE 3-1
2. FIGURE 3-2
3. FIGURE 3-3
Chapter 4
1. FIGURE 4-1
2. FIGURE 4-2
3. FIGURE 4-3
4. FIGURE 4-4
5. FIGURE 4-5
6. FIGURE 4-6
7. FIGURE 4-7
8. FIGURE 4-8
Chapter 5
1. FIGURE 5-1
2. FIGURE 5-2
3. FIGURE 5-3
4. FIGURE 5-4
5. FIGURE 5-5
6. FIGURE 5-6
7. FIGURE 5-7
8. FIGURE 5-8
9. FIGURE 5-9
10. FIGURE 5-10
11. FIGURE 5-11
12. FIGURE 5-12
Chapter 6
1. FIGURE 6-1
2. FIGURE 6-2
Chapter 7
1. FIGURE 7-1
2. FIGURE 7-2
3. FIGURE 7-3
4. FIGURE 7-4
5. FIGURE 7-5
6. FIGURE 7-6
7. FIGURE 7-7
8. FIGURE 7-8
9. FIGURE 7-9
10. FIGURE 7-10
11. FIGURE 7-11
12. FIGURE 7-12
Chapter 9
1. FIGURE 9-1
2. FIGURE 9-2
3. FIGURE 9-3
4. FIGURE 9-4
5. FIGURE 9-5
Chapter 10
1. FIGURE 10-1
2. FIGURE 10-2
3. FIGURE 10-3
4. FIGURE 10-4
5. FIGURE 10-5
6. FIGURE 10-6
7. FIGURE 10-7
8. FIGURE 10-8
9. FIGURE 10-9
10. FIGURE 10-10
11. FIGURE 10-11
12. FIGURE 10-12
Chapter 14
1. FIGURE 14-1
2. FIGURE 14-2
3. FIGURE 14-3
Chapter 17
1. FIGURE 17-1
Chapter 18
1. FIGURE 18-1
Chapter 23
1. FIGURE 23-1
2. FIGURE 23-2
Chapter 25
1. FIGURE 25-1
2. FIGURE 25-2
Chapter 27
1. FIGURE 27-1
2. FIGURE 27-2
3. FIGURE 27-3
4. FIGURE 27-4
Chapter 28
1. FIGURE 28-1
2. FIGURE 28-2
3. FIGURE 28-3
4. FIGURE 28-4
5. FIGURE 28-5
6. FIGURE 28-6
Chapter 29
1. FIGURE 29-1
2. FIGURE 29-2
3. FIGURE 29-3
4. FIGURE 29-4
Chapter 30
1. FIGURE 30-1
2. FIGURE 30-2
3. FIGURE 30-3
4. FIGURE 30-4
5. FIGURE 30-5
6. FIGURE 30-6
7. FIGURE 30-7
Chapter 31
1. FIGURE 31-1
2. FIGURE 31-2
3. FIGURE 31-3
4. FIGURE 31-4
Chapter 32
1. FIGURE 32-1
2. FIGURE 32-2
3. FIGURE 32-3
4. FIGURE 32-4
Chapter 33
1. FIGURE 33-1
2. FIGURE 33-2
3. FIGURE 33-3
4. FIGURE 33-4
5. FIGURE 33-5
6. FIGURE 33-6
7. FIGURE 33-7
8. FIGURE 33-8
Appendix D
1. FIGURE D-1
2. FIGURE D-2
3. FIGURE D-3
4. FIGURE D-4
5. FIGURE D-5
6. FIGURE D-6
7. FIGURE D-7
8. FIGURE D-8
9. FIGURE D-9

INTRODUCTION

The development of C++ started in 1982 by Bjarne Stroustrup, a Danish computer scientist, as the successor of C with Classes. In 1985, the first edition of The C++ Programming Language book was released. The first standardized version of C++ was released in 1998, called C++98. In 2003, C++03 came out and contained a few small updates. After that, it was silent for a while, but traction slowly started building up, resulting in a major update of the language in 2011, called C++11. From then on, the C++ Standard Committee has been on a three-year cycle to release updated versions, giving us C++14, C++17, and now C++20. All in all, with the release of C++20 in 2020, C++ is almost 40 years old and still going strong. In most rankings of programming languages in 2020, C++ is in the top four. It is being used on an extremely wide range of hardware, going from small devices with embedded microprocessors all the way up to multirack supercomputers. Besides wide hardware support, C++ can be used to tackle almost any programming job, be it games on mobile platforms, performance-critical artificial intelligence (AI) and machine learning (ML) software, real-time 3-D graphics engines, low-level hardware drivers, entire operating systems, and so on. The performance of C++ programs is hard to match with any other programming language, and as such, it is the de facto language for writing fast, powerful, and enterprise-class object-oriented programs. As popular as C++ has become, the language is surprisingly difficult to grasp in full. There are simple, but powerful, techniques that professional C++ programmers use that don't show up in traditional texts, and there are useful parts of C++ that remain a mystery even to experienced C++ programmers.

Too often, programming books focus on the syntax of the language instead of its real-world use. The typical C++ text introduces a major part of the language in each chapter, explaining the syntax and providing an example. Professional C++ does not follow this pattern. Instead of giving you just the nuts and bolts of the language with little practical context, this book will teach you how to use C++ in the real world. It will show you the little-known features that will make your life easier, as well as the programming techniques that separate novices from professional programmers.

WHO THIS BOOK IS FOR

Even if you have used the language for years, you might still be unfamiliar with the more advanced features of C++, or you might not be using the full capabilities of the language. Perhaps you write competent C++ code, but would like to learn more about design and good programming style in C++. Or maybe you're relatively new to C++ but want to learn the “right” way to program from the start. This book will meet those needs and bring your C++ skills to the professional level.

Because this book focuses on advancing from basic or intermediate knowledge of C++ to becoming a professional C++ programmer, it assumes that you have some knowledge about programming. Chapter 1, “A Crash Course in C++ and the Standard Library,” covers the basics of C++ as a refresher, but it is not a substitute for actual training in programming. If you are just starting with C++ but you have significant experience in another programming language such as C, Java, or C#, you should be able to pick up most of what you need from Chapter 1.

In any case, you should have a solid foundation in programming fundamentals. You should know about loops, functions, and variables. You should know how to structure a program, and you should be familiar with fundamental techniques such as recursion. You should have some knowledge of common data structures such as queues, and useful algorithms such as sorting and searching. You don't need to know about object-oriented programming just yet—that is covered in Chapter 5, “Designing with Objects.”

You will also need to be familiar with the compiler you will be using to compile your code. Two compilers, Microsoft Visual C++ and GCC, are introduced later in this introduction. For other compilers, refer to the documentation that came with your compiler.

WHAT THIS BOOK COVERS

Professional C++ uses an approach to C++ programming that will both increase the quality of your code and improve your programming efficiency. You will find discussions on new C++20 features throughout this fifth edition. These features are not just isolated to a few chapters or sections; instead, examples have been updated to use new features when appropriate.

Professional C++ teaches you more than just the syntax and language features of C++. It also emphasizes programming methodologies, reusable design patterns, and good programming style. The Professional C++ methodology incorporates the entire software development process, from designing and writing code to debugging and working in groups. This approach will enable you to master the C++ language and its idiosyncrasies, as well as take advantage of its powerful capabilities for large-scale software development.

Imagine users who have learned all of the syntax of C++ without seeing a single example of its use. They know just enough to be dangerous! Without examples, they might assume that all code should go in the main() function of the program or that all variables should be global—practices that are generally not considered hallmarks of good programming.

Professional C++ programmers understand the correct way to use the language, in addition to the syntax. They recognize the importance of good design, the theories of object-oriented programming, and the best ways to use existing libraries. They have also developed an arsenal of useful code and reusable ideas.

By reading and understanding this book, you will become a professional C++ programmer. You will expand your knowledge of C++ to cover lesser known and often misunderstood language features. You will gain an appreciation for object-oriented design and acquire top-notch debugging skills. Perhaps most important, you will finish this book armed with a wealth of reusable ideas that you can actually apply to your daily work.

There are many good reasons to make the effort to be a professional C++ programmer as opposed to a programmer who knows C++. Understanding the true workings of the language will improve the quality of your code. Learning about different programming methodologies and processes will help you to work better with your team. Discovering reusable libraries and common design patterns will improve your daily efficiency and help you stop reinventing the wheel. All of these lessons will make you a better programmer and a more valuable employee. While this book can't guarantee you a promotion, it certainly won't hurt.

HOW THIS BOOK IS STRUCTURED

This book is made up of five parts.

Part I, “Introduction to Professional C++,” begins with a crash course in C++ basics to ensure a foundation of C++ knowledge. Following the crash course, Part I goes deeper into working with strings, because strings are used extensively in most examples throughout the book. The last chapter of Part I explores how to write readable C++ code.

Part II, “Professional C++ Software Design,” discusses C++ design methodologies. You will read about the importance of design, the object-oriented methodology, and the importance of code reuse.

Part III, “C++ Coding the Professional Way,” provides a technical tour of C++ from the professional point of view. You will read about the best ways to manage memory in C++, how to create reusable classes, and how to leverage important language features such as inheritance. You will also learn techniques for input and output, error handling, string localization, how to work with regular expressions, and how to structure your code in reusable components called modules. You will read about how to implement operator overloading, how to write templates, how to put restrictions on template parameters using concepts, and how to unlock the power of lambda expressions and function objects. This part also explains the C++ Standard Library, including containers, iterators, ranges, and algorithms. You will also read about some additional libraries that are available in the standard, such as the libraries to work with time, dates, time zones, random numbers, and the filesystem.

Part IV, “Mastering Advanced Features of C++,” demonstrates how you can get the most out of C++. This part of the book exposes the mysteries of C++ and describes how to use some of its more advanced features. You will read about how to customize and extend the C++ Standard Library to your needs, advanced details on template programming, including template metaprogramming, and how to use multithreading to take advantage of multiprocessor and multicore systems.

Part V, “C++ Software Engineering,” focuses on writing enterprise-quality software. You'll read about the engineering practices being used by programming organizations today; how to write efficient C++ code; software testing concepts, such as unit testing and regression testing; techniques used to debug C++ programs; how to incorporate design techniques, frameworks, and conceptual object-oriented design patterns into your own code; and solutions for cross-language and cross-platform code.

The book concludes with a useful chapter-by-chapter guide to succeeding in a C++ technical interview, an annotated bibliography, a summary of the C++ header files available in the standard, and a brief introduction to the Unified Modeling Language (UML).

This book is not a reference of every single class, method, and function available in C++. The book C++17 Standard Library Quick Reference by Peter Van Weert and Marc Gregoire (Apress, 2019. ISBN: 978-1-4842-4923-9) is a condensed reference to all essential data structures, algorithms, and functions provided by the C++ Standard Library up until the C++17 standard. Appendix B lists a couple more references. Two excellent online references are:

cppreference.com: You can use this reference online or download an offline version for use when you are not connected to the Internet.
cplusplus.com/reference/

When I refer to a “Standard Library Reference” in this book, I am referring to one of these detailed C++ references.

The following are additional excellent online resources:

github.com/isocpp/CppCoreGuidelines: The C++ Core Guidelines are a collaborative effort led by Bjarne Stroustrup, inventor of the C++ language itself. They are the result of many person-years of discussion and design across a number of organizations. The aim of the guidelines is to help people to use modern C++ effectively. The guidelines are focused on relatively higher-level issues, such as interfaces, resource management, memory management, and concurrency.
github.com/Microsoft/GSL: This is an implementation by Microsoft of the Guidelines Support Library (GSL) containing functions and types that are suggested for use by the C++ Core Guidelines. It's a header-only library.
isocpp.org/faq: This is a large collection of frequently asked C++ questions.
stackoverflow.com: Search for answers to common programming questions, or ask your own questions.

CONVENTIONS

To help you get the most from the text and keep track of what's happening, a number of conventions are used throughout this book.

As for styles in the text:

Important words are italic when they are introduced.
Keyboard strokes are shown like this: Ctrl+A.
Filenames and code within the text are shown like so: monkey.cpp.
URLs are shown like this: wrox.com.

Code is presented in three different ways:

// Comments in code are shown like this.
In code examples, new and important code is highlighted like this.
Code that's less important in the present context or that has been shown before is formatted like this.

Paragraphs or sections that are specific to the C++20 standard have a little C++20 icon on the left, just as this paragraph does. C++11, C++14, and C++17 features are not marked with any icon.

WHAT YOU NEED TO USE THIS BOOK

All you need to use this book is a computer with a C++ compiler. This book focuses only on parts of C++ that have been standardized, and not on vendor-specific compiler extensions.

Any C++ Compiler

You can use whichever C++ compiler you like. If you don't have a C++ compiler yet, you can download one for free. There are a lot of choices. For example, for Windows, you can download Microsoft Visual Studio Community Edition, which is free and includes Visual C++. For Linux, you can use GCC or Clang, which are also free.

The following two sections briefly explain how to use Visual C++ and GCC. Refer to the documentation that came with your compiler for more details.

COMPILERS AND C++20 MODULE SUPPORT

At the time of this writing, there was no compiler available yet that fully supported C++20 modules. There was experimental support in some of the compilers, but it was still incomplete. This book uses modules everywhere. We did our best to make sure all sample code would compile once compilers fully support modules, but since we were not able to compile and test all examples, some errors might have crept in. When you use a compiler with support for modules and you encounter problems with any of the code samples, double-check the list of errata for the book at www.wiley.com/go/proc++5e to see if it's a known issue. If your compiler does not yet support modules, you can convert modularized code to non-modularized code, as explained briefly in Chapter 11, “Odds and Ends.”

Example: Microsoft Visual C++ 2019

First, you need to create a project. Start Visual C++ 2019, and on the welcome screen, click the Create A New Project button. If the welcome screen is not shown, select File ➪ New ➪ Project. In the Create A New Project dialog, search for the Console App project template with tags C++, Windows, and Console, and click Next. Specify a name for the project and a location where to save it, and click Create.

Once your new project is loaded, you can see a list of project files in the Solution Explorer. If this docking window is not visible, select View ➪ Solution Explorer. A newly created project will contain a file called <projectname>.cpp. You can start writing your C++ code in that .cpp file, or if you want to compile source code files from the downloadable source archive for this book, select the <projectname>.cpp file in the Solution Explorer and delete it. You can add new files or existing files to a project by right-clicking the project name in the Solution Explorer and then selecting Add ➪ New Item or Add ➪ Existing Item.

At the time of this writing, Visual C++ 2019 did not yet automatically enable C++20 features. To enable C++20 features, in the Solution Explorer window, right-click your project and click Properties. In the Properties window, go to Configuration Properties ➪ C/C++ ➪ Language, and set the C++ Language Standard option to ISO C++20 Standard or Preview - Features from the Latest C++ Working Draft, whichever is available in your version of Visual C++. These options are accessible only if your project contains at least one .cpp file.

Finally, select Build ➪ Build Solution to compile your code. When it compiles without errors, you can run it with Debug ➪ Start Debugging.

Module Support

At the time of this writing, Visual C++ 2019 did not yet have full support for modules. Authoring and consuming your own modules usually works just fine, but importing Standard Library headers such as the following did not yet work out of the box:

import <iostream>;

To make such import declarations work, for the time being you need to add a separate header file to your project, for example called HeaderUnits.h, which contains an import declaration for every Standard Library header you want to import. Here's an example:

// HeaderUnits.h
#pragma once
import <iostream>;
import <vector>;
import <optional>;
import <utility>;
// …

Next, right-click the HeaderUnits.h file in the Solution Explorer and click Properties. In Configuration Properties ➪ General, set Item Type to C/C++ Compiler and click Apply. Next, in Configuration Properties ➪ C/C++ ➪ Advanced, set Compile As to Compile as C++ Header Unit (/exportHeader) and click OK.

When you now recompile your project, all import declarations that have a corresponding import declaration in your HeaderUnits.h file should compile fine.

If you are using module implementation partitions (see Chapter 11), also known as internal partitions, then right-click all files containing such implementation partitions, click Properties, go to Configuration Properties ➪ C/C++ ➪ Advanced, and set the Compile As option to Compile as C++ Module Internal Partition (/internalPartition) and click OK.

Example: GCC

Create your source code files with any text editor you prefer and save them to a directory. To compile your code, open a terminal and run the following command, specifying all your .cpp files that you want to compile:

g++ -std=c++2a -o <executable_name> <source1.cpp> [source2.cpp …]

The -std=c++2a option is required to tell GCC to enable C++20 support. This option will change to -std=C++20 once GCC is fully C++20 compliant.

Module Support

At the time of this writing, GCC only had experimental support for modules through a special version of GCC (branch devel/c++-modules). When you are using such a version of GCC, module support is enabled with the -fmodules-ts option, which might change to -fmodules in the future.

Unfortunately, import declarations of Standard Library headers such as the following were not yet properly supported:

import <iostream>;

If that's the case, simply replace such import declarations with corresponding #include directives:

#include <iostream>

For example, the AirlineTicket example from Chapter 1 uses modules. After having replaced the imports for Standard Library headers with #include directives, you can compile the AirlineTicket example by changing to the directory containing the code and running the following command:

g++ -std=c++2a -fmodules-ts -o AirlineTicket AirlineTicket.cppm AirlineTicket.cpp AirlineTicketTest.cpp

When it compiles without errors, you can run it as follows:

./AirlineTicket

std::format Support

Many code samples in this book use std::format(), introduced in Chapter 1. At the time of this writing, there was no compiler yet that had support for std::format(). However, as long as your compiler doesn't support std::format() yet, you can use the freely available {fmt} library as a drop-in replacement:

Download the latest version of the {fmt} library from https://fmt.dev/ and extract the code on your machine.
Copy the include/fmt and src directories to fmt and src subdirectories in your project directory, and then add fmt/core.h, fmt/format.h, fmt/format-inl.h, and src/format.cc to your project.

Add a file called format (no extension) to the root directory of your project and add the following code to it:

#pragma once
#define FMT_HEADER_ONLY
#include "fmt/format.h"
namespace std
{
    using fmt::format;
    using fmt::format_error;
    using fmt::formatter;
}

Finally, add your project root directory (the directory containing the format file) as an additional include directory for your project. For example, in Visual C++, right click your project in the Solution Explorer, click Properties, go to Configuration Properties ➪ C/C++ ➪ General, and add $(ProjectDir); to the front of the Additional Include Directories option.

READER SUPPORT FOR THIS BOOK

The following sections describe different options to get support for this book.

Companion Download Files

As you work through the examples in this book, you may choose either to type in all the code manually or to use the source code files that accompany the book. However, I suggest you type in all the code manually because it greatly benefits the learning process and your memory. All of the source code used in this book is available for download at www.wiley.com/go/proc++5e.

Once you've downloaded the code, just decompress it with your favorite decompression tool.

How to Contact the Publisher

If you believe you've found a mistake in this book, please bring it to our attention. At John Wiley & Sons, we understand how important it is to provide our customers with accurate content, but even with our best efforts an error may occur.

To submit your possible errata, please e-mail it to our Customer Service Team at wileysupport@wiley.com with “Possible Book Errata Submission” as a subject line.

How to Contact the Author

If you have any questions while reading this book, the author can easily be reached at marc.gregoire@nuonsoft.com and will try to get back to you in a timely manner.