Glossary

An attribute that warns if a caller ignores the return value.

A function with an auto parameter, which is secretly a template (C++20).

The binary-level contract that lets separately compiled code work together.

A path that starts from the top of the file system.

A class you cannot create objects of, because it has a pure virtual function.

public, private, or protected: who may use a class member.

The type a std::variant currently holds.

The number that says where an object sits in memory.

The unary & that gives an object's address.

A compiler option that makes memory bugs crash loudly with a report.

A simple struct or array that can be initialized member by member with braces.

A standard function like std::sort or std::find that works on a range.

A second name for the same thing.

Averaged over a long sequence of operations.

The functions and types code can call: the contract at the source level.

The actual value passed to a function in a call.

The rules that bring mixed number types to a common type before arithmetic.

The three parts of a test: set up, do the thing, check the result.

A fixed number of elements of one type, stored side by side.

A built-in array turning into a pointer to its first element.

Human-readable text form of machine instructions.

A check that fails, loudly, if a condition is false.

Replacing the value of a variable that already exists.

The rule that groups operators of the same precedence, left to right or right to left.

An operation, or a std::atomic variable, that no other thread can see half-done.

A [[...]] annotation that gives the compiler extra information.

A keyword that lets the compiler work out a variable's type from its initializer.

Code that checks your code and reports pass or fail by itself.

Created when its block starts running, destroyed when it ends.

The case a recursive function answers directly, without recursing.

The class another class inherits from.

In vcpkg, a registry snapshot that fixes the version of every package.

After an exception, nothing leaks and every object is still valid.

An iterator that can step forward or back, one element at a time.

Notation for how an algorithm's cost grows with the size of its input.

Stored builds of packages so they need not be recompiled.

A file of raw bytes, not meant to be read as text.

A tree stored in an array where each parent is ordered before its children.

An operator such as &, |, ^ or ~ that works on each bit of an integer separately.

Code between { and }, which starts a new scope.

Checking an index is valid before using it.

Initializing with braces, as in int n{5};, which forbids narrowing.

A named line of development that can move ahead separately.

A change that makes existing code stop compiling or behave differently.

A marker that makes the debugger pause the program on a line.

One slot of a hash table, holding the entries whose keys hash there.

Temporary memory where data collects before being written or processed.

Writing past the end of a block of memory.

A named set of build settings, such as Debug or Release.

A tool that works out which files to compile and runs the commands.

The folder where CMake writes generated files and build output.

Looping constantly to check a condition, burning CPU while waiting.

The smallest addressable unit of memory: 8 bits on every mainstream platform.

A character array ended by a zero byte, the way C stores text.

A widely used set of rules for writing modern, safe C++.

The official document that defines the C++ language and library.

The operator() member that runs when an object is called like a function.

The chain of function calls that are currently in progress.

A function you hand to other code for it to call later.

The rules for how arguments and return values are passed between functions.

How many elements a vector has room for before it must grow.

How a lambda gets access to variables from the surrounding code.

A C++ test framework with natural-looking assertions.

A single letter, digit, or symbol of text.

A standard-library build mode that catches misuse of iterators and indexes.

The LLVM project's C, C++, and Objective-C compiler, standard on macOS.

Clang with MSVC-compatible command-line options, for Windows.

A tool that rewrites C++ code into a consistent format.

A Clang-based linter that checks for bugs and style problems and can fix some.

A user-defined type that bundles data with the functions that act on it.

A class written once for any type, like std::vector<T>.

Letting the compiler deduce a class template's arguments from a constructor call (C++17).

JetBrains' cross-platform C++ IDE, built around CMake.

A source of the current time: system, steady, or high-resolution.

The object a lambda expression creates, holding its captured values.

A cross-platform tool that generates build files from one project description.

The VS Code extension that configures, builds, and debugs CMake projects.

The file that describes a CMake project: its targets, sources, and settings.

The checked-in file that holds a project's CMake presets.

Teammates reading a change before it is merged.

A line you type in a terminal to make something happen.

A word typed after a program's name when it is started, handed to main.

A note in source code that the compiler ignores.

A saved snapshot of the project, with a message saying what changed.

A function that says whether one element should come before another.

An operator like <, ==, or != that compares two values and gives bool.

The compiler found code that breaks the language rules.

A language whose programs are translated to machine code before they run.

The program that translates C++ source code into machine code.

A tool that reuses compiler output when the same file is compiled again.

The command (g++, clang++, cl) that runs every build stage for you.

Features one compiler accepts that are not standard C++.

Building a class out of member objects rather than by inheriting.

An operator like += that updates a variable using its own value.

A C and C++ package manager that can download prebuilt binaries.

Conan's description of the compiler and settings a build uses.

A named, compile-time test of what a type must support.

A way for a thread to sleep until another thread says something changed.

A breakpoint that pauses only when a condition you give is true.

The cond ? a : b operator: an if-else that produces a value.

The NameConfig.cmake file that lets find_package find an installed library.

The CMake step that reads CMakeLists.txt and writes the build files.

A keyword that makes a variable read-only after it is initialized.

Marking everything const that should not change, and letting the compiler check it.

An iterator that lets you read elements but not change them.

A member function that promises not to change the object.

A read-only alias, the usual way to pass large objects.

An expression the compiler can evaluate while compiling.

Takes the same time however big the data is: O(1).

Marks a function that must run at compile time.

A keyword asking for a value, or a function, to be usable at compile time.

A requirement a template argument must meet for the template to be used.

A special member function that initializes a new object.

A standard-library object that holds a collection of elements.

A restricted interface over another container, like a stack or queue.

Stored next to each other in memory, with no gaps.

Building and testing every change automatically on a server.

What a function promises and what it requires of its callers.

The hidden bookkeeping a std::shared_ptr keeps next to its object.

A member function that says how to turn an object into another type, such as bool.

The operator= that overwrites an existing object with a copy of another.

The constructor that makes a new object as a copy of an existing one.

The compiler building a returned object directly in its destination, with no copy or move.

Initializing with =, as in int n = 5;.

Writing assignment as: copy the argument, then swap contents with it.

A function that can pause and later resume where it left off (C++20).

Which lines of code your tests actually ran.

An open-source static analyzer for C and C++.

Small, fast memory near the processor that holds recently used data.

Code that touches shared data and must run in only one thread at a time.

Comma-separated values: a plain-text table, one record per line.

CMake's test runner.

The folder a terminal, or a running program, is working in.

Referring to an object that no longer exists.

A pointer to memory whose object has already been destroyed.

A variable that is part of each object of a struct or class.

Two threads touching the same data at once, at least one writing, without synchronization.

Rules for moving a ! inside: negate each part and swap && with ||.

Threads each waiting for a lock another holds, so none can continue.

A build with no optimization and full debug information, for development.

Extra data in a build that maps machine code back to your source.

A tool that pauses a running program so you can inspect it.

A statement that introduces a name and its type.

A copy that duplicates the pointed-to data too.

A value a parameter uses when the caller leaves it out.

The constructor that takes no arguments.

A value written next to a member's declaration, used unless a constructor sets it.

Whether a shared library's symbols are exported unless you say otherwise.

A declaration that also supplies the thing itself: the body or the storage.

The checklist a change must pass before it counts as finished.

A constructor that hands the whole setup job to another constructor of the same class.

A function declared = delete so that any use of it is a compile error.

The function a smart pointer calls to release what it owns.

A library your project needs in order to build or run.

Marking something as still working but scheduled for removal.

std::deque: a double-ended queue, fast to add or remove at both ends.

Follow a pointer to the object it points at.

A class that inherits from another.

Naming members when brace-initializing an aggregate, as in {.x = 1} (C++20).

A special member function that runs automatically when an object is destroyed.

A PowerShell window with the MSVC compiler already on its path.

A message from the compiler about your code: an error or a warning.

A listing of exactly which lines changed between two versions.

A folder: a named container for files and other folders.

An object that turns an engine's raw bits into numbers of a given shape and range.

A loop that runs its body first and tests its condition at the bottom.

A very lightweight, single-header C++ test framework.

Freeing the same memory twice: undefined behavior.

A conversion from a base-class pointer or reference to a derived-class one.

A tool that generates reference documentation from comments in code.

A length of time, with its units in the type: std::chrono::milliseconds.

Picking which function body to run based on the object's actual type.

The actual type of the object at run time.

Leaving a function as soon as the answer is known.

An input at the boundary of what the code handles: empty, zero, maximum.

A file that tells editors basic settings such as indentation and line endings.

One item stored in an array or container.

The rule for storing text characters as bytes.

The point where there is no more input to read.

The order in which a number's bytes are stored in memory.

A type whose values are a fixed list of named choices.

One of the named values listed inside an enum.

A named setting, such as HOME or PATH, that every program inherits when it starts.

The starting moment a clock counts its time points from.

The pre-C++20 two-step for deleting matching elements from a vector.

An object thrown to signal an error, which unwinds the stack until caught.

A file the operating system can run as a program.

The number a program hands back to the system when it ends.

A constructor marked explicit so it is never used for silent conversions.

A conversion you write out on purpose, with a cast.

A macro such as MYLIB_EXPORT that marks declarations as part of a library's API.

A named group of installed targets that CMake writes a targets file for.

The list of symbols a shared library makes available to other programs.

A piece of code that produces a value, like a + b or f(x).

The dot-and-letters ending of a file name, like .cpp.

Declares functions with C linkage: no name mangling, callable from C.

The >> operator that reads a value from a stream.

The flag a stream sets when a read or write did not work.

In a switch, running on into the next case because break is missing.

A tool warning about a problem that isn't really there.

A merge where Git just moves the branch pointer ahead.

A CMake module that downloads a dependency's source and builds it with your project.

A CMake list of a target's headers, which knows how to install them.

A stream connected to a file: std::ifstream or std::ofstream.

The operating system's tree of folders and files.

A keyword that stops further overriding or inheriting.

The CMake command that locates an installed library.

An integer type of an exact size, such as std::int32_t.

Shared setup that several tests start from.

An option on a command line that changes how a tool behaves.

A number type for fractions, such as double, stored as an approximation.

A C++17 expression that applies an operator across every element of a parameter pack.

The part after the colon in {:...} that sets width, precision, and alignment.

A string with {} placeholders that std::format or std::print fills in.

Declaring a class's name without its definition, as in class Engine;.

An iterator that can only step ahead, one element at a time.

A T&& parameter with T deduced, which binds to lvalues and rvalues alike.

A function that is not a member of any class.

A function or class a class lets see its private members.

A specialization that fills in every template argument, written after template <>.

A named block of code that takes inputs, does a job, and can return a result.

Running a function, by writing its name followed by arguments in parentheses.

An object you can call like a function, because its class defines operator().

Several functions sharing one name, told apart by their parameters.

A pointer that holds the address of a function.

A function written once for any type, with the type as a parameter.

A type built into the language, such as int, double, char, or bool.

The GNU Compiler Collection, the standard compiler on most Linux systems.

The GNU command-line debugger, used with GCC on Linux.

The kind of build files CMake writes: Ninja, Makefiles, Visual Studio, or Xcode.

A $<...> CMake expression evaluated at build-generation time, per configuration.

A lambda with auto parameters, which works for any argument type.

A member function that returns a private member's value.

The most widely used version control system.

GitHub's built-in continuous integration service.

The outermost namespace, where names outside any namespace block live.

Data that any part of the program can read or change.

A variable declared outside every function, visible to the whole file or program.

Google's C++ test framework.

A range that includes its start but stops just before its end: [first, last).

A catch clause: the code that runs when a matching exception arrives.

The relationship composition expresses: a Car has an Engine.

The long hexadecimal ID that names a commit.

Two different keys landing in the same bucket.

A function that turns a key into a number used to pick a bucket.

A table that finds values by computing a slot number from the key.

A small callable struct that turns a key into a hash number for an unordered container.

A file of declarations that other source files #include.

A library delivered entirely as headers, with nothing to link.

The memory area for objects you create and destroy on demand.

A friend function defined inside the class, found only through its arguments.

An editor that also builds, runs, and debugs your code.

Doing it twice has the same effect as doing it once.

A sequence of if/else if tests where only the first true branch runs.

Not a valid C++ program by the standard's rules.

Behavior the standard leaves to each compiler, which must document its choice.

A type conversion the compiler does for you without being asked.

On Windows, the small .lib you link to use a DLL.

A CMake target that stands for a library built outside your project.

#ifndef/#define/#endif lines that stop a header being pasted in twice.

Include the header for everything a file uses directly.

A type that has been declared but not yet defined.

Rebuilding only what changed since the last build.

The garbage an uninitialized local variable holds.

An element's position, counting from 0.

Defining a new class as an extension of an existing one.

A using-declaration that lets a derived class be built the same ways as its base.

A capture that creates and initializes a new variable inside the lambda.

Giving a variable its first value when it is created.

A keyword that allows identical definitions in several translation units.

A variable marked inline (C++17) so a header can define one object shared by every file.

The optimizer copying a function's body into its caller.

Checking input is usable before trusting it.

On macOS, the path a dynamic library tells programs to load it from.

The root folder a project installs into.

The compiler generating real code from a template for specific arguments.

Extra checking code the compiler inserts into your program.

A whole number, with no fractional part.

Division of two whole numbers that keeps only the whole part, so 7 / 2 is 3.

The set of operations code may use, without saying how they work.

A CMake target with no compiled code, only settings to pass on.

Visible only inside its own translation unit.

A rule about an object's data that must always hold.

The relationship public inheritance should express: a Circle is a Shape.

The C++ ABI used by GCC and Clang on Linux and macOS.

An object that marks a position in a container and can move to the next one.

The group an iterator belongs to, which says what moves it allows.

A container change that leaves existing iterators, pointers, or references pointing at stale memory.

Wait for a thread to finish.

An entry that pairs a lookup key with its stored value.

In VS Code's CMake Tools, the compiler you choose to build with.

A small unnamed function written right where it is used.

The C++ edition the compiler is told to follow, such as C++20.

Computing each result only when it is asked for.

A sanitizer that lists heap memory never freed when the program exits.

Prewritten, compiled code your program can use.

GCC's implementation of the C++ standard library.

The legal terms under which code may be used and shared.

The period during run time when an object exists.

The character(s) marking the end of a line: \n or \r\n.

Time grows in step with the size of the data: O(n).

A build failure from the linker: a name is missing or defined twice.

Whether a name refers to the same thing in other .cpp files.

A chain of nodes, each holding one element and a link to the next.

The tool that joins object files and libraries into one program.

A packaged version of Linux, such as Ubuntu or Fedora.

The LLVM debugger, standard on macOS and used with Clang.

The average number of elements per bucket.

The part of the operating system that starts a program running.

Implemented with hardware atomic instructions rather than a hidden mutex.

A file recording exact dependency versions so every build uses the same ones.

The program runs without complaint but gives the wrong answer.

An operator that combines true/false values: &&, ||, !.

A notification sent before the other thread started waiting, and so missed.

An expression that names an object with an identity, like a variable.

A preprocessor name that is replaced by text before compiling.

The build script read by make: rules for building files from other files.

vcpkg reading a project's dependencies from its own vcpkg.json.

A CI setup that runs the same job across several OSes or compilers.

A function declared inside a class that works on one object of it.

The : member(value), ... part of a constructor that initializes members directly.

Copying an object by copying each member in turn.

Heap memory that is never freed because nothing remembers it.

Rules for what other memory changes an atomic operation makes visible to other threads.

A debugger panel showing raw bytes at an address.

Combining the changes from two branches.

Two branches changed the same lines, and Git needs you to choose.

A well-known pseudo-random engine: std::mt19937.

A timing test of one small piece of code.

A header of declarations and a source file of definitions that share a name, like convert.h and convert.cpp.

A Windows .def file that lists which functions a DLL exports.

C++20's replacement for headers: compiled interfaces you import.

The unevenness from using rand() % n to pick a number.

The class of the complete object being built, at the bottom of the family tree.

The operator= that replaces an object's contents by taking another's resources.

The constructor that builds a new object by taking over another's resources.

Transferring an object's resources instead of copying them.

A type that can be moved but not copied, like std::unique_ptr.

The build system Visual Studio uses for its own projects.

Microsoft's C++ compiler, which comes with Visual Studio.

A Windows environment that provides GCC and Unix-style tools.

A generator whose one build folder can build any configuration, chosen at build time.

A link error: two object files both define the same function or variable.

A class built on more than one base class at once.

A lock that lets only one thread at a time into a section of code.

Encoding a C++ function's namespace and parameter types into its symbol name.

A named region that groups declarations and keeps their names apart.

A shorter name for a namespace, as in namespace fs = std::filesystem;.

Outside every function and class, directly inside a namespace.

A project's rule for how names are spelled, such as snake_case.

A conversion that can lose information, like double to int.

A loop inside another loop's body; the inner loop runs fully on every outer round.

A type declared inside a class, named like Outer::Inner.

Big-endian: the byte order used by network protocols.

A small, fast build system that CMake can generate files for.

The program is broken, but the tools are not required to tell you.

One separately allocated piece of a linked structure, holding an element and links.

A promise that a function never throws.

Something the project deliberately will not do.

An object that looks at data it does not own and does not free.

A template parameter that is a value, like N in std::array<int, N>.

The zero byte '\0' that marks the end of a C string.

A pointer that deliberately points at nothing: nullptr.

Time grows very slowly: doubling the data adds about one step.

The compiled machine code for one source file, not yet a program.

A loop that runs one time too many or one too few.

Each function or variable may be defined once in the whole program.

The position just after the last element: valid to point at, not to read.

A type users can hold a pointer to but cannot see inside.

A hash-table design that stores one entry per slot and, on a collision, tries the next slots until one is free.

Flags saying how to open a file: read, write, append, binary.

A value an operator acts on.

A symbol such as +, ==, or << that acts on values.

Defining what +, ==, <<, and other operators mean for your type.

Keeping all build output in a separate folder from your source.

A reference parameter used to hand a result back to the caller.

A result too big (or too small) for its type to hold.

How the compiler picks which overload a call means.

A derived class's replacement for a virtual function; also the keyword that checks it.

Which object is responsible for freeing a resource.

Conan's hash identifying one specific binary build of a package.

A tool that downloads and installs software or libraries for you.

Unused bytes the compiler places inside a struct to align its members.

Compiling several files at once, one per processor core.

A variable in a function's definition that receives an input.

A template parameter written with ... that stands for zero or more types or arguments.

A specialization of a class template for a pattern of arguments, such as any pointer.

The function works on the caller's own object, not a copy.

The function gets its own copy of the argument.

The written address of a file or folder.

A Make rule that covers many files at once, such as %.o: %.cpp.

A license that allows almost any use, as long as you keep the notice.

Hiding a class's private data behind a pointer to an implementation struct.

A file that holds only characters, with no hidden formatting.

The target machine and system a build is for, such as x64 Windows.

A variable that holds the address of another object.

Adding to a pointer to move it along an array.

A value like &Item::price that names a member of a class, not of an object.

Describes a class with at least one virtual function.

A vcpkg recipe describing how to build one library.

Machine code that works wherever in memory it is loaded.

n++: produce the old value, then add 1.

The rules for which operator binds first when there are no parentheses.

A header the compiler has already processed and saved, to speed up builds.

Something that must be true before a function is called.

A function that answers yes or no about an element.

The platform's normal path separator: \ on Windows, / elsewhere.

++n: add 1 first, then produce the new value.

The first build step: it pastes in headers and handles # lines.

In a build rule, a file the target is made from.

A named, saved set of CMake settings, stored in CMakePresets.json.

The general definition of a template, used when no specialization matches.

The chip that actually carries out a program's instructions.

A tiny, very fast storage slot inside the processor.

A tool that measures where a program spends its time.

A set of instructions a computer can carry out.

A precise, written language for giving a computer instructions.

The set of source files and settings that build one program or library.

A function a ranges algorithm applies to each element before comparing it.

Visual Studio's settings dialog for a project.

The part of a library its users are allowed to depend on.

A header meant for users of a library.

A request to review and merge a branch's changes.

A virtual function with no body in the base class, written = 0.

A name written with its namespace or class, like std::vector.

A table whose rows have different lengths, such as a vector of vectors filled row by row.

Tie a resource's lifetime to an object: acquire in the constructor, release in the destructor.

Jumping straight to any element by position, in one step.

The source of raw pseudo-random bits, such as std::mt19937.

A sequence of elements you can iterate over, from a beginning to an end.

A view-maker you chain with |, like views::filter.

A for loop that visits each element of a container in turn.

A vector moving its elements into a new, bigger block of memory.

A function solving a problem by calling itself on a smaller case.

Write a failing test (red), then make it pass (green).

A compile error: the same thing is defined twice in one file.

Another name for an existing object.

How many owners currently share an object.

Shared pointers that point at each other and so never reach zero.

Several names share one object, so a change through one shows through all.

A bug that returns, or a feature that stops working, after a change.

A hash table growing its bucket array and redistributing every element.

A path measured from the folder you are currently in.

An optimized build meant for real use.

Still works after being moved to a different folder.

The leftover from whole-number division, written with %, so 7 % 2 is 1.

A copy of the repository hosted elsewhere, such as on GitHub.

A project folder together with its full version history.

The requires condition attached to a template.

A requires { ... } block listing the operations a type must support.

Anything that must be acquired and later given back: memory, a file, a lock.

The function returns its own copy of the result.

The result a function hands back to its caller.

A search path stored inside a binary telling the loader where to find its shared libraries.

The record of each polymorphic object's real type that dynamic_cast and typeid read.

A resource-managing class defines destructor, copy, and move operations together.

If a class needs a custom destructor, copy constructor, or copy assignment, it needs all three.

Let members that manage themselves do the work, and write none of the five.

What a finished program needs while it runs, such as the operating system and shared libraries.

A failure that happens while the program is running.

The support library that compiled code relies on at run time.

An expression for a temporary, or an object about to be discarded.

A T&& reference that binds only to rvalues, used to detect movable objects.

A compiler option that adds run-time checks and reports bugs as they happen.

The part of the code where a name can be used.

The :: that joins a namespace or class name to a member name.

The starting value that fixes which pseudo-random sequence an engine produces.

Assigning an object to itself, as in a = a;.

A header that compiles on its own, because it includes everything it needs.

Version numbers MAJOR.MINOR.PATCH that signal what kind of change was made.

A special value like -1 or npos that means "not found" or "no result".

A container that keeps elements in the order you put them.

A member function that changes a private member, checking the new value.

The word in a diagnostic that says how serious it is, such as error, warning, or note.

The pre-C++20 trick of disabling a template when substitution fails.

An inner name hiding an outer one with the same spelling.

A copy that shares the original's heap data instead of duplicating it.

A library loaded at run time and shared by programs: a DLL, .so, or .dylib.

Several owners jointly keep one object alive.

The program inside a terminal that reads and runs your commands.

&& and || stop as soon as the answer is known.

A generator whose build folder holds one configuration, chosen when you configure.

Copying a derived object into a base object, losing the derived part.

A class that owns a heap object and deletes it for you.

A quick check that the program starts and does the basics at all.

Visual Studio's container for one or more projects.

The name a Linux shared library says programs should load it by, such as libfoo.so.1.

The text of a program, written by a person.

The C++20 <=> operator, which compares two values in one go.

A short written description of what the program must do.

A separate definition of a template used instead of the general one for certain arguments.

A throwaway experiment to answer one question before committing to a design.

A waiting thread waking up even though nobody notified it.

A sort that keeps equal elements in their original order.

The memory area for function-call frames and local variables.

The block of stack memory one function call uses for its locals.

A crash from using up the call stack, often by recursing too deep.

The list of calls that were active when something went wrong.

Destroying local objects, frame by frame, as an exception travels up.

The list of changes chosen to go into the next commit.

Out of date: an input changed after the output was built.

The stream a program reads typed input from: std::cin.

The library of types and functions every C++ implementation provides.

The stream a program prints normal output to, usually the terminal.

The eof, fail, and bad bits a stream uses to report problems.

A design where a program is always in one of a few named states.

A tool that finds likely bugs by reading code, without running it.

A bundle of object files copied into each program that links it.

A local variable marked static that keeps its value between calls.

A class member that belongs to the class as a whole, not to each object.

Lives for the whole run of the program.

The type the compiler sees for an expression.

Every variable's type is fixed and checked before the program runs.

A result that holds either a value or an error explaining why not (C++23).

A type that holds a file path and handles separators for each platform.

A wrapper that can hold any callable with a given signature.

An object that will hold a result computed elsewhere, perhaps on another thread.

A container of key-value pairs, kept sorted by key.

A cast that marks an object as OK to move from. It moves nothing itself.

A value that may or may not be present.

A container of unique values, kept sorted.

A pointer whose object is shared and freed when the last owner goes away.

A pointer-and-length view of a contiguous run of elements (C++20).

A cheap, read-only window onto characters stored somewhere else.

The single, movable owner of a heap object.

A hash table of key-value pairs: fast lookup, no ordering.

A type-safe union: holds exactly one of several listed types at a time.

A non-owning observer of a shared_ptr's object, used to break cycles.

Run the current line, stopping inside the first function it calls.

Run until the current function returns, then stop in its caller.

Run the current line, including any calls in it, and stop at the next line.

A flag a std::jthread passes to its function to ask it to stop.

Rules for when an object's memory is created and freed.

A source or destination of characters you read from or write to in order.

Text written in double quotes in source code, such as "Hello, world!\n".

After an exception, it is as if the operation never happened.

A small wrapper type that stops different kinds of values being mixed up.

A type that groups named data members together.

Unpacking a struct, pair, or tuple into named variables in one declaration.

A placeholder function that compiles but does nothing real yet.

The rule that picks the more constrained of two matching overloads.

The list in an object file of names it defines and names it needs.

A C-style struct holding a type tag plus a union of possible values.

Something a build produces, such as an executable or a library.

A pattern for a function or class with the types left as parameters.

The actual type or value filled in for a template parameter.

The compiler working out template arguments from the function call's arguments.

A placeholder in a template, such as T in template <typename T>.

An unnamed object created during an expression and destroyed soon after.

A text window where you type commands and read their output.

A library that makes writing, running, and reporting tests easy.

A tag on a CTest test so you can run a group of tests together.

Opening a file so line endings are converted for the platform.

Inside a member function, this points at the object it was called on.

An independent path of execution running alongside others in the same program.

A sanitizer that detects data races between threads.

Signal an error by creating an exception and leaving the current function.

A moment in time on a particular clock.

How close two floating-point numbers must be to count as equal.

The set of tools that turn source code into a running program.

A CMake script, given at configure time, that sets up compilers or a package manager.

A dependency of one of your dependencies.

A header you get only because another header happened to include it.

The ordered steps that turn source text into a program.

One .cpp file plus everything it includes: what the compiler sees at once.

Make every warning stop the build, so none are ignored.

vcpkg's name for a target platform and linkage, like x64-windows.

A type that can be copied just by copying its bytes.

Empty a file when opening it.

Cutting off the fraction of a number instead of rounding, so 2.7 becomes 2.

Code wrapped in try { } whose exceptions the following handlers can catch.

What kind of value something is, which decides its size and what you can do with it.

A second name for an existing type.

A compile-time question about a type, or a type computed from another, from <type_traits>.

Code the standard puts no requirements on: anything may happen.

A sanitizer that reports undefined behavior such as signed overflow.

The integer type an enum is stored as.

A test of one small piece of code on its own.

Compiling several .cpp files glued together as one translation unit.

A namespace { ... } whose contents are private to one .cpp file.

One of several allowed outcomes, and the compiler need not tell you which.

A one-line summary of how to call a program, printed when it is called wrongly.

Settings a library passes on to whatever links it.

Accessing heap memory after it has been freed.

One sentence describing something a user wants to do, and why.

using std::cout;: makes one name usable without its prefix.

using namespace std;: makes every name in a namespace usable unqualified.

The standard way to store Unicode text as bytes.

The state an object is left in after being moved from.

Whether an expression names a lasting object (lvalue) or a temporary one (rvalue).

Initializing with empty braces, which gives zero or the default.

Copies are independent: changing one never changes another.

A named piece of memory that holds a value of one type.

An array whose size is set at run time: allowed in C, not in C++.

Microsoft's open-source C++ package manager.

std::vector: a resizable array that manages its own memory.

Copying a dependency's source code directly into your repository.

Keeping a recorded history of every change to your project.

A lightweight range that presents elements without owning or copying them.

A destructor declared virtual so deleting through a base pointer runs the right one.

A member function a derived class can replace, chosen at run time.

A callable with one overload per alternative, passed to std::visit.

Microsoft's IDE for Windows, which bundles the MSVC compiler.

Microsoft's free cross-platform code editor.

The thinnest version of the program that builds, runs, and tests end to end.

Real calendar time, what a clock on the wall shows.

A compiler message about code that is legal but probably wrong.

An expression the debugger re-evaluates and shows each time the program pauses.

A breakpoint that fires when a variable's value changes.

Spaces, tabs, and line breaks.

The files you actually see and edit in a repository.

The most work an operation can take for any input of a given size.

Apple's IDE for macOS, built on Clang.