Programming glossary

ABI

Application Binary Interface: the low-level rules that compiled components follow so they can work together, including calling conventions, data layout and symbol naming.

Also encountered as: application binary interface

Appears in: Lesson 01

abstract base class

A base class that cannot be instantiated directly, usually because it contains at least one pure virtual function. It defines a common contract for derived classes.

Also encountered as: abstract base, abstract bases

Appears in: Lesson 21

abstraction

A simplified view of something that exposes what a user needs while hiding unnecessary implementation detail. Functions, classes and interfaces are common programming abstractions.

Also encountered as: abstractions

Appears in: Lesson 01, Lesson 04, Lesson 09, Lesson 12, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 23

access control

The rules controlling which code may use a class member. In C++, the main access levels are public, protected and private.

Also encountered as: access levels, access specifier, access specifiers

Appears in: Lesson 18, Lesson 24

address

A number identifying a location in memory. A pointer stores a memory address.

Also encountered as: memory address, memory addresses, addresses

Appears in: Lesson 01, Lesson 03, Lesson 05, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 22, Lesson 23

address-of operator

The unary & operator when it is used to obtain the memory address of an object.

Also encountered as: address operator

Appears in: Lesson 14

algorithm

A precise sequence of steps for solving a problem or performing a computation.

Also encountered as: algorithms, algorithmic

Appears in: Lesson 01, Lesson 04, Lesson 06, Lesson 10, Lesson 11, Lesson 14, Lesson 15, Lesson 18, Lesson 20, Lesson 22, Lesson 23

API

Application Programming Interface: the functions, types and rules that one piece of software exposes for other code to use.

Also encountered as: APIs, application programming interface, application programming interfaces

Appears in: Lesson 01, Lesson 04, Lesson 07, Lesson 08, Lesson 14, Lesson 15, Lesson 16, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

argument

A value or expression supplied at a function call. The function receives it through a corresponding parameter.

Also encountered as: arguments, function argument, function arguments

Appears in: Lesson 01, Lesson 04, Lesson 05, Lesson 06, Lesson 08, Lesson 09, Lesson 10, Lesson 13, Lesson 14, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23

array

A fixed-size sequence of elements of the same type stored contiguously in memory and accessed by an index.

Also encountered as: arrays, C-style array, C-style arrays

Appears in: Lesson 05, Lesson 10, Lesson 14, Lesson 15, Lesson 17, Lesson 24

assembler

A tool that translates assembly-language instructions into machine code.

Also encountered as: assembler programming

Appears in: Lesson 01

assembly language

A low-level, human-readable representation of processor instructions, closely related to the machine code executed by a CPU.

Also encountered as: assembly, assembler language

Additional course reference term.

assignment

Storing a new value in an existing object or variable, commonly using the = operator.

Also encountered as: assign, assigned, assigning, assignment operator

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 08, Lesson 12, Lesson 13, Lesson 14, Lesson 16, Lesson 20, Lesson 22, Lesson 24

associativity

The rule deciding how operators of the same precedence are grouped, such as left-to-right or right-to-left.

Appears in: Lesson 13, Lesson 22, Lesson 23

automatic storage duration

The lifetime category normally used by local variables: the object is created when execution reaches its declaration and destroyed when its block is left.

Also encountered as: automatic storage

Appears in: Lesson 14, Lesson 15, Lesson 24

average-case complexity

An estimate of an algorithm's resource use for a typical input under stated assumptions.

Also encountered as: average case, average-case

Additional course reference term.

base class

A class whose data or behaviour is inherited by another class. The inheriting class is called a derived class.

Also encountered as: base classes, superclass, superclasses

Appears in: Lesson 19, Lesson 21, Lesson 24

benchmark

A controlled measurement used to compare the performance of code, algorithms or systems.

Also encountered as: benchmarks, benchmarking

Appears in: Lesson 01, Lesson 04, Lesson 10, Lesson 17, Lesson 21

Big O notation

A notation describing how an algorithm's resource requirements grow as its input grows, while ignoring constant factors and lower-order terms.

Also encountered as: Big-O, Big O, asymptotic complexity

Appears in: Lesson 01

binary

A base-two representation using 0 and 1. The word can also describe compiled machine-code output.

Also encountered as: binaries

Appears in: Lesson 09, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23

black box

A component considered only through its inputs and outputs, without relying on knowledge of its internal implementation.

Also encountered as: black-box, black box testing, black-box testing

Appears in: Lesson 01

block

A group of statements enclosed by braces in C++. A block introduces a scope.

Also encountered as: code block, code blocks, blocks

Appears in: Lesson 03, Lesson 04, Lesson 08, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 19, Lesson 21, Lesson 24

Boolean

A logical value with two possibilities: true or false. The C++ Boolean type is bool.

Also encountered as: Boolean value, Boolean values, bool

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 11, Lesson 12, Lesson 13, Lesson 18, Lesson 19, Lesson 20, Lesson 22, Lesson 23, Lesson 24

branch

A point where control flow can follow different paths, such as an if statement or switch case.

Also encountered as: branches, branching

Appears in: Lesson 10, Lesson 12, Lesson 13, Lesson 21

branchless programming

Writing a calculation so it avoids conditional control-flow branches, sometimes to improve predictable processor performance.

Also encountered as: branchless, branchless variant, branchless variants

Appears in: Lesson 01

buffer

A region of memory used to hold data temporarily while it is being produced, transferred or consumed.

Also encountered as: buffers, buffering

Appears in: Lesson 09, Lesson 15, Lesson 16, Lesson 17, Lesson 24

buffer overflow

Writing beyond the allocated boundary of a buffer. This is undefined behaviour and can cause crashes, corruption or security vulnerabilities.

Also encountered as: buffer overrun, buffer overruns, buffer overflows

Additional course reference term.

bug

A defect in software that causes incorrect or unintended behaviour.

Also encountered as: bugs, software bug, programming error, programming errors

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 12, Lesson 14, Lesson 15, Lesson 16, Lesson 18, Lesson 19, Lesson 24

byte

A small unit of memory, normally eight bits on modern systems.

Also encountered as: bytes

Appears in: Lesson 04, Lesson 09, Lesson 16, Lesson 17, Lesson 18, Lesson 24

C++

A compiled, statically typed, general-purpose programming language used extensively for game engines, real-time systems and performance-sensitive software.

Also encountered as: C plus plus

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

C++ reference

A C++ alias bound to an existing object. A reference must normally refer to a valid object and cannot later be reseated.

Also encountered as: references, C++ references

Appears in: Lesson 03, Lesson 04, Lesson 07, Lesson 08, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 23

C++ template

A C++ declaration that describes a family of classes, functions or variables parameterised by types or compile-time values.

Also encountered as: template, templates, templated

Appears in: Lesson 07, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 23

cache

Small, fast storage that keeps recently or frequently used data close to the processor.

Also encountered as: CPU cache, processor cache, caches

Appears in: Lesson 04, Lesson 10, Lesson 12, Lesson 17, Lesson 22, Lesson 23

cache locality

The tendency of a program to access nearby or recently used memory, allowing processor caches to work effectively.

Also encountered as: memory locality, locality, data locality

Appears in: Lesson 01, Lesson 10, Lesson 12, Lesson 17, Lesson 21

call graph

A diagram or data structure showing which functions call which other functions.

Also encountered as: call graphs, call-graph, call-graphs

Appears in: Lesson 01

call site

The exact location in source code where a function is invoked.

Also encountered as: call sites, call-site, call-sites

Appears in: Lesson 04, Lesson 06, Lesson 08, Lesson 15, Lesson 19, Lesson 21, Lesson 22, Lesson 23

cast

An explicit request to treat or convert a value as another type. C++ provides named casts such as static_cast and dynamic_cast.

Also encountered as: casting, casts

Appears in: Lesson 06, Lesson 08, Lesson 13, Lesson 21, Lesson 23

circular dependency

A dependency cycle in which two or more components require one another. In header files this often appears as cyclic includes.

Also encountered as: circular dependencies, circular call, circular calls, cyclic include, cyclic includes

Appears in: Lesson 06, Lesson 07

class

A user-defined C++ type that groups data and functions into a description from which objects can be created.

Also encountered as: classes

Appears in: Lesson 01, Lesson 03, Lesson 07, Lesson 08, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

class template

A recipe for generating classes from one or more template arguments, such as the type of element a container stores.

Also encountered as: class templates

Appears in: Lesson 09, Lesson 20, Lesson 23

code

Instructions expressed in a programming language. Source code is the human-readable form written by programmers.

Also encountered as: program code, source code

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

code bloat

An undesirable increase in executable size, sometimes caused when templates generate many similar machine-code versions.

Also encountered as: binary bloat

Appears in: Lesson 23

command-line interface

A text-based way of interacting with a program by entering commands and arguments, often abbreviated to CLI.

Also encountered as: CLI, command line, command-line

Appears in: Lesson 05, Lesson 09

compile time

The stage when source code is analysed and translated before the program runs.

Also encountered as: compile-time, compilation time

Appears in: Lesson 04, Lesson 07, Lesson 08, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 23

compiler

A program that translates source code into another form, typically object code or machine code, while reporting language errors.

Also encountered as: compilers, compile, compiled, compiling, compilation

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

compiler optimisation

A compiler transformation intended to improve properties such as speed or code size while preserving the program's required observable behaviour.

Also encountered as: compiler optimization, compiler optimisations, compiler optimizations, optimise, optimize, optimised, optimized

Appears in: Lesson 01, Lesson 04, Lesson 10, Lesson 12, Lesson 17, Lesson 20, Lesson 21

complexity

A description of the time or memory an algorithm requires as a function of its input size.

Also encountered as: algorithmic complexity, computational complexity

Appears in: Lesson 01, Lesson 09, Lesson 12, Lesson 18, Lesson 19, Lesson 23

composition

Building a type from objects of other types rather than inheriting their implementation. It represents a has-a relationship.

Also encountered as: object composition

Appears in: Lesson 18, Lesson 19, Lesson 21

computability

The study of which problems can, in principle, be solved by an algorithm.

Also encountered as: computable

Appears in: Lesson 01

concept

A C++20 feature that gives a readable name to requirements on template arguments and allows templates to be constrained.

Also encountered as: concepts, C++ concept, C++ concepts

Appears in: Lesson 08, Lesson 16, Lesson 23

condition

An expression evaluated as true or false to control whether a branch or loop body executes.

Also encountered as: conditions, conditional expression

Appears in: Lesson 01, Lesson 05, Lesson 06, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 16, Lesson 17, Lesson 18, Lesson 22

conditional operator

The C++ ?: operator, which selects one of two expressions according to a Boolean condition. It is also called the ternary operator.

Also encountered as: ternary operator, ?: operator, conditional (ternary) operator

Appears in: Lesson 13

const-correctness

Using const consistently so code clearly expresses which objects may be modified and which must remain unchanged.

Also encountered as: const correctness, const-correct

Appears in: Lesson 14, Lesson 18, Lesson 20, Lesson 22, Lesson 24

constant

A named value that is not intended or permitted to change after it has been established.

Also encountered as: constants

Appears in: Lesson 01, Lesson 02, Lesson 07, Lesson 10, Lesson 11, Lesson 13, Lesson 17, Lesson 23

constraint

A requirement that a template argument must satisfy before a templated declaration can be used.

Also encountered as: constraints, constrained template, constrained templates

Appears in: Lesson 01, Lesson 09, Lesson 18, Lesson 21, Lesson 23

constructor

A special class function that establishes a new object's initial state when the object is created.

Also encountered as: constructors

Appears in: Lesson 03, Lesson 06, Lesson 14, Lesson 15, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

container

A data structure that stores a collection of objects, such as std::vector, std::array or std::map.

Also encountered as: containers, standard container, standard containers

Appears in: Lesson 03, Lesson 04, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 21, Lesson 22, Lesson 23, Lesson 24

contiguous memory

A sequence of adjacent memory locations. Arrays and std::vector store their elements contiguously.

Also encountered as: contiguous storage, contiguously

Appears in: Lesson 17

control flow

The order in which a program executes statements, including branches, loops, calls and returns.

Also encountered as: flow control, execution flow

Appears in: Lesson 03, Lesson 10, Lesson 11, Lesson 12, Lesson 24

conversion

Changing a value from one type or representation to another. A conversion may be implicit or explicitly requested.

Also encountered as: conversions, type conversion, type conversions

Appears in: Lesson 03, Lesson 05, Lesson 06, Lesson 08, Lesson 12, Lesson 13, Lesson 14, Lesson 17, Lesson 19, Lesson 20, Lesson 22, Lesson 23

copy assignment

Assigning the state of one existing object to another existing object of the same type.

Also encountered as: copy assignment operator

Appears in: Lesson 24

copy constructor

A constructor that creates a new object from an existing object of the same type.

Also encountered as: copy constructors

Appears in: Lesson 18, Lesson 24

correctness

The degree to which software satisfies its specified requirements for all relevant inputs and states.

Also encountered as: correct program, correct code

Appears in: Lesson 01, Lesson 02, Lesson 04, Lesson 07, Lesson 10, Lesson 15, Lesson 16, Lesson 17, Lesson 20, Lesson 21, Lesson 23

covariant return type

A C++ overriding rule that permits a virtual function to return a pointer or reference to a more-derived type than the base version returns.

Also encountered as: covariant return, covariant returns, covariant return types

Appears in: Lesson 21

CPU

Central Processing Unit: the processor that executes machine instructions.

Also encountered as: processor, processors, central processing unit

Appears in: Lesson 08, Lesson 10, Lesson 17

CPU register

A small, fast storage location inside a processor that can hold data while instructions are being executed.

Also encountered as: CPU registers, processor register, processor registers

Appears in: Lesson 02

CRTP

Curiously Recurring Template Pattern: a C++ pattern where a derived class passes itself as a template argument to its base, often enabling static polymorphism.

Also encountered as: Curiously Recurring Template Pattern

Appears in: Lesson 19, Lesson 21

dangling pointer

A pointer that still holds an address after the object at that address has ceased to exist.

Also encountered as: dangling pointers, dangle, dangles, dangling

Appears in: Lesson 03, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18

data structure

A particular way of organising data so operations on it can be performed effectively.

Also encountered as: data structures

Appears in: Lesson 01

deallocation

Releasing dynamically allocated storage so it can be reused.

Also encountered as: deallocate, deallocated, free memory, freeing memory

Appears in: Lesson 15, Lesson 24

debug build

A program build configured to aid debugging, normally retaining symbols and checks while applying little or no optimisation.

Also encountered as: debug builds, debug mode

Appears in: Lesson 01, Lesson 15

debugger

A tool for pausing a running program, inspecting state and stepping through execution to diagnose faults.

Also encountered as: debuggers

Appears in: Lesson 01, Lesson 02, Lesson 06, Lesson 09, Lesson 11

debugging

The process of locating, understanding and correcting defects in software.

Also encountered as: debug, debugged

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 09, Lesson 13, Lesson 14, Lesson 15, Lesson 17, Lesson 21, Lesson 23

declaration

A statement that introduces a name and its type or signature to the compiler. Some declarations are also definitions.

Also encountered as: declarations, declare, declared, declaring

Appears in: Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 12, Lesson 13, Lesson 14, Lesson 16, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

definition

A declaration that fully creates an entity, such as allocating storage for a variable or supplying a function body.

Also encountered as: definitions, define, defined

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 12, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

dereference operator

The unary * operator when it accesses the object located at the address stored in a pointer.

Also encountered as: dereference, dereferenced, dereferencing

Appears in: Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 17

derived class

A class that inherits from a base class.

Also encountered as: derived classes, subclass, subclasses

Appears in: Lesson 18, Lesson 19, Lesson 20, Lesson 21

destructor

A special class function that runs when an object is destroyed, allowing its owned resources to be released safely.

Also encountered as: destructors, destruction, deconstructor, deconstructors

Appears in: Lesson 03, Lesson 05, Lesson 14, Lesson 15, Lesson 16, Lesson 18, Lesson 19, Lesson 21, Lesson 24

deterministic algorithm

An algorithm whose next step is completely determined by its current state and input.

Also encountered as: deterministic, deterministically

Appears in: Lesson 01, Lesson 06, Lesson 12, Lesson 24

diamond problem

An ambiguity that can occur in multiple inheritance when two base-class paths lead to the same ancestor.

Also encountered as: inheritance diamond

Appears in: Lesson 19

disassembly

A representation of compiled machine code as assembly-language instructions, often used to inspect what the compiler produced.

Also encountered as: disassemble, disassembled

Appears in: Lesson 09

dispatch

The process of selecting which function implementation a call should execute. Virtual functions use dynamic dispatch at runtime.

Also encountered as: dynamic dispatch, dispatching, dynamically dispatched

Appears in: Lesson 12, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 24

do-while loop

A loop that executes its body before checking its condition, so the body always runs at least once.

Also encountered as: do-while, do while, do–while, do–while loop, do-while loops

Appears in: Lesson 11, Lesson 12

double deletion

Attempting to release the same allocation twice. This is undefined behaviour.

Also encountered as: double delete, double free

Appears in: Lesson 14, Lesson 15, Lesson 24

dynamic allocation

Requesting storage while the program is running, normally from the heap. In C++, raw dynamic allocation uses new and delete, though RAII types are preferred.

Also encountered as: dynamically allocated, dynamic memory allocation

Appears in: Lesson 01, Lesson 03, Lesson 17

dynamic type

The actual most-derived type of a polymorphic object during execution, which may differ from the static type of the pointer or reference used to access it.

Also encountered as: runtime type

Appears in: Lesson 19, Lesson 21

dynamic_cast

A C++ cast that safely checks certain conversions within a polymorphic class hierarchy at runtime.

Also encountered as: dynamic cast, downcast, downcasts, downcasting

Appears in: Lesson 21

encapsulation

Keeping an object's representation and invariants behind a controlled public interface so callers cannot freely create invalid state.

Also encountered as: encapsulate, encapsulated

Appears in: Lesson 15, Lesson 16, Lesson 18, Lesson 19, Lesson 20, Lesson 24

end-of-file

A condition indicating that no more data can be read from a file or input stream, commonly abbreviated EOF.

Also encountered as: EOF, end of file

Appears in: Lesson 11

entry point

The defined place where program execution begins. In a normal hosted C++ program, the entry function is main.

Also encountered as: program entry point, entry function

Appears in: Lesson 05, Lesson 09

enumeration

A user-defined type whose valid values are a fixed set of named constants. In C++, it is declared with enum or enum class.

Also encountered as: enum, enums, enumerations

Appears in: Lesson 05, Lesson 12, Lesson 18, Lesson 19, Lesson 21

evaluation order

The language rules determining when the parts of an expression are evaluated relative to one another.

Also encountered as: order of evaluation

Appears in: Lesson 06, Lesson 12

exception

A mechanism for reporting and propagating an unusual failure through the call stack using throw, try and catch.

Also encountered as: exceptions, exception handling

Appears in: Lesson 05, Lesson 07, Lesson 15, Lesson 18, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

exception safety

The guarantees a component provides about resource management and program state when an operation exits by throwing an exception.

Also encountered as: exception-safe

Additional course reference term.

executable

A program file in a form the operating system can load and run.

Also encountered as: executable file, executables

Appears in: Lesson 01, Lesson 05, Lesson 08, Lesson 09

exit code

An integer returned to the operating environment when a program finishes. Zero conventionally indicates success.

Also encountered as: exit status, return code, exit codes

Appears in: Lesson 05

explicit conversion

A type conversion deliberately requested in source code, such as with a named cast or an explicit constructor.

Also encountered as: explicit conversions, explicit cast

Appears in: Lesson 13, Lesson 22

expression

A combination of values, names, calls and operators that produces a value or effect.

Also encountered as: expressions

Appears in: Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 21, Lesson 22, Lesson 23, Lesson 24

external linkage

A C++ linkage property allowing the same named entity to be referred to from different translation units.

Appears in: Lesson 08

final specifier

The C++ final keyword used to prevent further overriding of a virtual function or further inheritance from a class.

Also encountered as: final

Appears in: Lesson 01, Lesson 02, Lesson 04, Lesson 05, Lesson 06, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 15, Lesson 16, Lesson 17, Lesson 19, Lesson 21, Lesson 22, Lesson 24

flame graph

A visual profile showing where a program spends execution time, with wider blocks representing more sampled work.

Also encountered as: flamegraph, flamegraphs, flame graphs

Appears in: Lesson 01

floating-point type

A numeric type that represents a finite range of real-number approximations, including fractional values. C++ floating-point types include float, double and long double.

Also encountered as: floating point type, floating-point types, floating point types, floating-point number, floating-point numbers

Additional course reference term.

for loop

A loop that normally groups initialisation, continuation condition and update into one control statement.

Also encountered as: for-loop, for loops, for-loops

Appears in: Lesson 10, Lesson 12

forward declaration

A declaration that introduces a name before its complete definition appears, allowing earlier code to refer to it in limited ways.

Also encountered as: forward declarations, function prototype, function prototypes

Appears in: Lesson 06, Lesson 07

friend function

A non-member function granted access to a class's private and protected members by a friend declaration inside that class.

Also encountered as: friend functions

Appears in: Lesson 20

function

A named, reusable unit of behaviour that can receive parameters and may return a value.

Also encountered as: functions

Appears in: Lesson 02, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

function call

An expression that invokes a function, supplies its arguments and transfers control to its body.

Also encountered as: function calls, calling a function, calling functions

Appears in: Lesson 04, Lesson 06, Lesson 12, Lesson 13, Lesson 15, Lesson 22

function overloading

Defining several functions with the same name but different parameter lists, allowing overload resolution to choose among them.

Also encountered as: overloaded function, overloaded functions, function overload, function overloads

Appears in: Lesson 06, Lesson 23

function signature

The parts of a function declaration used to distinguish or describe the function, especially its name and parameter types.

Also encountered as: function signatures, signature, signatures

Appears in: Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 14, Lesson 19, Lesson 20, Lesson 21, Lesson 22

function template

A recipe that generates functions from template arguments, allowing one algorithm to work with multiple suitable types.

Also encountered as: function templates

Appears in: Lesson 20, Lesson 23

fuzz testing

Automated testing that supplies many unexpected, random, extreme or malformed inputs to uncover crashes, hangs, memory errors and violated rules.

Also encountered as: fuzz, fuzzing, fuzz test, fuzz tests

Appears in: Lesson 01

fuzzer

A tool that repeatedly generates or mutates inputs and feeds them to a program to search for faults.

Also encountered as: fuzzers

Appears in: Lesson 01

fuzzing oracle

The rule used during fuzz testing to decide whether an input exposed a failure, such as a crash, sanitizer report or broken invariant.

Also encountered as: fuzzing oracles

Appears in: Lesson 01

generic programming

Writing algorithms and data structures in terms of required capabilities rather than one specific type. C++ templates are a principal mechanism for this.

Also encountered as: generic code

Appears in: Lesson 23

global variable

A variable declared at namespace scope, rather than inside a function or class. Its broad visibility and lifetime require careful control.

Also encountered as: global variables, global state, global name, global names

Appears in: Lesson 01, Lesson 08, Lesson 18

guard clause

An early check that immediately exits or handles an invalid case, keeping the main path of a function less deeply nested.

Also encountered as: guard clauses, early return, early returns

Appears in: Lesson 12, Lesson 15, Lesson 24

header file

A source file, usually with a .h or .hpp extension, used to share declarations and template definitions between translation units.

Also encountered as: header files, header, headers

Appears in: Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 15, Lesson 18, Lesson 23

heap

A region used for dynamic storage whose objects live until explicitly released or until an owning RAII object releases them.

Also encountered as: heap memory, free store

Appears in: Lesson 03, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 23, Lesson 24

Heisenbug

A fault whose behaviour changes or disappears when someone tries to observe or debug it, often because timing or memory layout changes.

Also encountered as: Heisenbugs

Appears in: Lesson 01

identifier

A name written in source code to identify a program entity such as a variable, function, type or namespace.

Also encountered as: identifiers

Appears in: Lesson 02, Lesson 03, Lesson 04, Lesson 08, Lesson 14, Lesson 15, Lesson 16, Lesson 19, Lesson 21, Lesson 22

if statement

A control-flow statement that executes code conditionally according to a Boolean expression.

Also encountered as: if statements, if-else, if/else, if-else chain, if-else chains

Appears in: Lesson 12, Lesson 13, Lesson 19, Lesson 21

implicit conversion

A type conversion the language or compiler performs without an explicit cast at the point of use.

Also encountered as: implicit conversions, implicit cast

Appears in: Lesson 06, Lesson 13, Lesson 20, Lesson 22

include directive

The #include preprocessor directive, which replaces the directive with the contents of another file before compilation.

Also encountered as: #include, include directives

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

include guard

Preprocessor directives that ensure a header's contents are processed no more than once in a translation unit.

Also encountered as: include guards

Appears in: Lesson 07

infinite loop

A loop whose termination condition is never reached, so it continues indefinitely unless interrupted.

Also encountered as: infinite loops, runaway loop, runaway loops

Appears in: Lesson 10, Lesson 11

inheritance

An object-oriented mechanism for defining a derived class in terms of a base class. It usually models an is-a relationship.

Also encountered as: inherit, inherits, inherited

Appears in: Lesson 07, Lesson 18, Lesson 19, Lesson 20

initialisation

Establishing an object's first value as the object comes into existence. This is distinct from assigning to an already-existing object.

Also encountered as: initialization, initialise, initialize, initialised, initialized, initialising, initializing

Appears in: Lesson 02, Lesson 03, Lesson 04, Lesson 06, Lesson 09, Lesson 10, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 18, Lesson 19, Lesson 22, Lesson 24

inline

A C++ specifier that permits equivalent definitions in multiple translation units. It also historically suggested replacing a call with the function body, though that optimisation decision belongs to the compiler.

Also encountered as: inline function, inline functions, inline variable, inline variables

Appears in: Lesson 04, Lesson 07, Lesson 08, Lesson 20, Lesson 23

input/output

Communication between a program and external sources or destinations, such as the keyboard, screen, files or network. Often abbreviated I/O.

Also encountered as: I/O, input and output, IO

Appears in: Lesson 04, Lesson 08, Lesson 09, Lesson 11, Lesson 12

instance

A particular object created from a class or other type description.

Also encountered as: instances, instantiate an object

Additional course reference term.

instantiation

Creating a concrete entity from a general description. For templates, it means generating a class or function for particular template arguments.

Also encountered as: instantiate, instantiated, instantiating, template instantiation, template instantiations

Appears in: Lesson 03, Lesson 07, Lesson 21, Lesson 23

integer

A whole-number value. C++ provides several integer types with different sizes and signedness.

Also encountered as: integers, integer type, integer types

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 08, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 17, Lesson 18, Lesson 20, Lesson 22, Lesson 23

integration test

A test that checks whether multiple components work correctly together.

Also encountered as: integration tests, integration testing

Additional course reference term.

interface

The publicly usable operations and guarantees through which code interacts with a component. In C++, an abstract base class is often used to express an interface.

Also encountered as: interfaces, public interface

Appears in: Lesson 01, Lesson 04, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

internal linkage

A C++ linkage property that keeps a name local to one translation unit. An unnamed namespace is the usual modern mechanism.

Appears in: Lesson 08

invariant

A condition that must remain true at a specified point, such as throughout an object's valid lifetime or before and after each loop iteration.

Also encountered as: invariants, class invariant, class invariants, loop invariant, loop invariants

Appears in: Lesson 01, Lesson 10, Lesson 11, Lesson 15, Lesson 16, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

iterator

An object that identifies a position in a sequence and provides operations for accessing and moving between elements.

Also encountered as: iterators

Appears in: Lesson 04, Lesson 14, Lesson 16, Lesson 17

iterator invalidation

A change to a container that makes one or more existing iterators, pointers or references unsafe to use.

Also encountered as: invalidated iterator, invalidated iterators, invalidation

Appears in: Lesson 16, Lesson 17, Lesson 18

LHS and RHS

Left-hand side and right-hand side: the operands appearing to the left and right of an operator.

Also encountered as: LHS, RHS, left-hand side, right-hand side

Appears in: Lesson 02, Lesson 12, Lesson 20, Lesson 22, Lesson 24

library

A reusable collection of compiled code, source code or both, provided for programs to use.

Also encountered as: libraries, third-party library, third-party libraries

Appears in: Lesson 01, Lesson 03, Lesson 05, Lesson 07, Lesson 08, Lesson 09, Lesson 16, Lesson 22

lifetime

The period during program execution when an object exists and may legally be used. The course also calls this an object's extent.

Also encountered as: lifetimes, object lifetime, object lifetimes, extent

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 06, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 23, Lesson 24

lifetime extension

A C++ rule that allows certain temporary objects to live longer when bound to an appropriate reference.

Also encountered as: extended lifetime

Appears in: Lesson 16

linker

A build tool that combines object files and libraries, resolves symbol references and produces an executable or library.

Also encountered as: linkers, linking, link

Appears in: Lesson 07, Lesson 08, Lesson 09, Lesson 21, Lesson 23

linker error

A failure while combining compiled components, often caused by a missing definition, duplicate definition or incompatible binary interface.

Also encountered as: link errors, link error, linker errors

Appears in: Lesson 07, Lesson 08

local variable

A variable declared inside a function or block. Its name is visible only within the relevant scope.

Also encountered as: local variables, local object, local objects

Appears in: Lesson 02, Lesson 03, Lesson 16, Lesson 24

lookup table

A data structure containing preselected results or actions that code retrieves by key or index instead of recomputing or branching through many cases.

Also encountered as: lookup tables, dispatch table, dispatch tables

Appears in: Lesson 12, Lesson 19, Lesson 21

loop

A control-flow structure that repeatedly executes a body while a condition or range requires it.

Also encountered as: loops, iteration, iterations, iterate

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 05, Lesson 06, Lesson 10, Lesson 11, Lesson 12, Lesson 14, Lesson 17, Lesson 21

lvalue

A C++ expression category that identifies an object with a persistent identity and location, allowing operations such as taking its address.

Also encountered as: lvalues, lvalue expression, lvalue expressions

Appears in: Lesson 13

machine code

Binary processor instructions in the form a CPU executes directly.

Also encountered as: machine instruction, machine instructions

Appears in: Lesson 01, Lesson 10

macro

A preprocessor name that is replaced textually before C++ compilation. Macros do not follow ordinary C++ type or scope rules.

Also encountered as: macros, #define

Appears in: Lesson 04, Lesson 07, Lesson 11

main function

The required entry function of an ordinary hosted C++ program. Its return value supplies the program's exit code.

Also encountered as: main(), main function

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

memory allocation

Reserving storage for an object or data. Allocation can be automatic, static or dynamic depending on how the storage is obtained.

Also encountered as: allocate memory, allocated memory, allocation, allocations

Appears in: Lesson 03, Lesson 15, Lesson 16, Lesson 17, Lesson 21, Lesson 24

memory leak

Allocated memory that a program no longer needs but has lost the ability to release, causing resource use to grow unnecessarily.

Also encountered as: memory leaks, leak, leaks, leaking memory

Appears in: Lesson 01, Lesson 02, Lesson 14, Lesson 15, Lesson 16, Lesson 18, Lesson 22, Lesson 23, Lesson 24

memory safety

The property that code accesses only valid memory within the correct bounds and lifetime.

Also encountered as: memory-safe, memory error, memory errors

Appears in: Lesson 01, Lesson 14, Lesson 15

metamorphic testing

Testing relationships between multiple executions when the exact answer may be difficult to know, such as expecting a predictable transformation of the output after transforming the input.

Also encountered as: metamorphic test, metamorphic tests

Appears in: Lesson 01

method

A function associated with a class or object. In C++, the formal term is member function.

Also encountered as: methods, member function, member functions

Appears in: Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 24

microbenchmark

A narrowly focused benchmark measuring one small operation or component under controlled conditions.

Also encountered as: microbenchmarks, micro-benchmark, micro-benchmarks

Appears in: Lesson 01

move assignment

Replacing an existing object's state by transferring resources from an expiring object of the same type.

Also encountered as: move assignment operator

Appears in: Lesson 16, Lesson 24

move constructor

A constructor that creates an object by transferring resources from an expiring object of the same type.

Also encountered as: move constructors

Appears in: Lesson 24

move semantics

C++ rules that allow resources to be transferred from an object that will no longer need them, avoiding an unnecessary deep copy.

Also encountered as: resource move, resource moves

Appears in: Lesson 15

multiple definition error

A linker failure caused when a program supplies more definitions of an entity than the One Definition Rule permits.

Also encountered as: multiple definition errors, duplicate definition, duplicate definitions

Appears in: Lesson 07, Lesson 08

multiple inheritance

Inheritance in which one derived class has more than one direct base class.

Appears in: Lesson 19

name hiding

A C++ lookup effect where a declaration in an inner scope or derived class prevents declarations with the same name in an outer scope or base class from being found normally.

Also encountered as: hidden name, hidden names

Appears in: Lesson 19

namespace

A named scope used to organise declarations and prevent unrelated names from colliding.

Also encountered as: namespaces

Appears in: Lesson 08, Lesson 09, Lesson 16, Lesson 20, Lesson 22

namespace alias

A shorter or interchangeable name assigned to an existing namespace.

Also encountered as: namespace aliases

Appears in: Lesson 08

new and delete

Built-in C++ operators for raw dynamic allocation and deallocation. Modern code normally puts them behind RAII types rather than using them directly throughout an application.

Also encountered as: new / delete, new/delete, new operator, delete operator

Appears in: Lesson 03, Lesson 14, Lesson 15, Lesson 22, Lesson 23, Lesson 24

noexcept

A C++ specifier declaring that a function is not expected to let exceptions escape. Destructors should normally be non-throwing.

Also encountered as: non-throwing

Appears in: Lesson 01, Lesson 15, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 22, Lesson 23, Lesson 24

non-deterministic algorithm

A theoretical or practical computation whose next choice is not uniquely fixed by its current state; randomness is one practical source of non-determinism.

Also encountered as: non-deterministic, nondeterministic, non-deterministically

Appears in: Lesson 01, Lesson 11

non-type template parameter

A template parameter representing a compile-time value rather than a type, commonly abbreviated NTTP.

Also encountered as: non-type template parameters, NTTP, NTTPs

Appears in: Lesson 23

null pointer

A pointer value deliberately representing no object. Modern C++ spells the null pointer literal nullptr.

Also encountered as: null pointers, nullptr

Appears in: Lesson 05, Lesson 12, Lesson 14, Lesson 15, Lesson 16, Lesson 21, Lesson 24

NVI pattern

Non-Virtual Interface pattern: public non-virtual functions enforce a stable workflow and call protected or private virtual functions for custom behaviour.

Also encountered as: Non-Virtual Interface, NVI

Appears in: Lesson 19, Lesson 21

object

A region of storage with a type, value and lifetime. In object-oriented code, it is commonly an instance of a class.

Also encountered as: objects

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 06, Lesson 07, Lesson 08, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

object file

Compiler output containing machine code and symbol information that a linker combines with other object files and libraries.

Also encountered as: object files, object code

Appears in: Lesson 07, Lesson 08

object slicing

Loss of a derived object's additional state and behaviour when it is copied into a base-class object by value.

Also encountered as: slicing, sliced object, sliced objects

Appears in: Lesson 19, Lesson 21, Lesson 22

object-oriented programming

A programming style that organises behaviour and state around objects, commonly using encapsulation, composition, inheritance and polymorphism.

Also encountered as: object oriented, object-oriented, OOP, object orientation

Appears in: Lesson 18, Lesson 19, Lesson 20

observable behaviour

The externally detectable effects of a program that a conforming implementation must preserve, such as required input/output effects.

Also encountered as: observable behavior

Appears in: Lesson 01, Lesson 05

One Definition Rule

The C++ rule controlling how many definitions an entity may have across a program and when repeated definitions must be equivalent. It is often abbreviated ODR.

Also encountered as: ODR, one-definition rule

Appears in: Lesson 07, Lesson 08, Lesson 23

operator

A language symbol or keyword that performs an operation on one or more operands, such as +, == or *.

Also encountered as: operators

Appears in: Lesson 09, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 18, Lesson 20, Lesson 22, Lesson 23, Lesson 24

operator overloading

Defining how an existing C++ operator behaves for a user-defined type while preserving the operator's expected meaning.

Also encountered as: overloaded operator, overloaded operators, operator overload, operator overloads

Appears in: Lesson 09, Lesson 22

oracle

A rule or mechanism that decides whether the observed result of a test is correct.

Also encountered as: test oracle, test oracles, oracles

Appears in: Lesson 01

out-of-bounds access

Reading or writing outside the valid index range of an array, buffer or container. With unchecked C++ access this is usually undefined behaviour.

Also encountered as: out of bounds, out-of-bounds, bounds error, bounds errors

Appears in: Lesson 05, Lesson 14, Lesson 17

overload resolution

The compile-time process that selects the best matching function or operator from a set of candidates.

Also encountered as: overload selection

Appears in: Lesson 08, Lesson 21, Lesson 22, Lesson 23

override

A derived-class virtual function that replaces the implementation inherited from a base class. The C++ override specifier asks the compiler to verify this intent.

Also encountered as: overrides, overriding, overridden

Appears in: Lesson 18, Lesson 19, Lesson 21

ownership

Responsibility for controlling a resource's lifetime and ensuring it is released exactly once. RAII and smart pointers make ownership explicit.

Also encountered as: owner, owned resource, owned resources

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 06, Lesson 08, Lesson 12, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 23, Lesson 24

P versus NP

The unresolved question of whether every problem whose proposed solution can be checked in polynomial time can also be solved in polynomial time.

Also encountered as: P = NP, P vs NP, P versus NP, P and NP

Appears in: Lesson 01

parameter

A named input declared by a function or template. A function call supplies an argument for a function parameter.

Also encountered as: parameters, function parameter, function parameters, parameter list, parameter lists

Appears in: Lesson 04, Lesson 05, Lesson 06, Lesson 09, Lesson 14, Lesson 15, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23

pass by pointer

Passing an object's address as a function argument, allowing the function to access the original object and also represent no object with a null pointer.

Also encountered as: passing by pointer, pointer parameter, pointer parameters

Appears in: Lesson 17

pass by reference

Binding a function parameter directly to the caller's object instead of making a copy. A const reference permits read-only access.

Also encountered as: passing by reference, reference parameter, reference parameters

Appears in: Lesson 14

pass by value

Giving a function its own parameter object initialised from the argument. Changes to that parameter do not directly change the caller's object.

Also encountered as: passing by value, value parameter, value parameters

Appears in: Lesson 04, Lesson 06, Lesson 07

perfect forwarding

A template technique that passes an argument onward while preserving whether it was an lvalue or rvalue and retaining its const qualification.

Also encountered as: forwarding reference, forwarding references

Appears in: Lesson 23

pointer

An object whose value is a memory address, allowing indirect access to another object or function.

Also encountered as: pointers

Appears in: Lesson 01, Lesson 03, Lesson 05, Lesson 06, Lesson 07, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 23, Lesson 24

pointer arithmetic

Adding, subtracting or comparing pointers within the bounds of the same array so they refer to different elements.

Appears in: Lesson 14

polymorphism

The ability to use a common interface with values of different concrete types. C++ supports runtime polymorphism through virtual functions and compile-time polymorphism through templates.

Also encountered as: polymorphic, dynamic polymorphism, runtime polymorphism

Appears in: Lesson 12, Lesson 18, Lesson 19, Lesson 21, Lesson 22, Lesson 24

polynomial time

A running-time bound expressible as a polynomial in the input size, such as n, n squared or n cubed.

Also encountered as: polynomial-time

Appears in: Lesson 01

postcondition

A condition that a function or operation promises will be true after it completes successfully.

Also encountered as: postconditions, post-condition, post-conditions

Appears in: Lesson 01, Lesson 04, Lesson 10, Lesson 19, Lesson 20, Lesson 21

postfix increment

The expression value++: it yields the old value and then increments the object.

Also encountered as: post-increment, postfix operator

Appears in: Lesson 22

pragma once

The widely supported #pragma once directive, which asks the compiler to process a header file only once per translation unit.

Also encountered as: #pragma once

Appears in: Lesson 05, Lesson 07, Lesson 08

precedence

The rules deciding which operators bind more tightly when an expression has no parentheses.

Also encountered as: operator precedence

Appears in: Lesson 13, Lesson 22

precompiled header

A compiler-generated representation of commonly included headers that can reduce repeated compilation work, often abbreviated PCH.

Also encountered as: precompiled headers, PCH

Appears in: Lesson 07

precondition

A condition that must be true before a function or operation is called correctly.

Also encountered as: preconditions, pre-condition, pre-conditions

Appears in: Lesson 03, Lesson 04, Lesson 12, Lesson 17, Lesson 18, Lesson 20, Lesson 21

prefix increment

The expression ++value: it increments the object and yields the new value.

Also encountered as: pre-increment, prefix operator

Additional course reference term.

preprocessor

The stage that handles directives such as #include, #define and conditional compilation before the C++ compiler processes the resulting translation unit.

Also encountered as: preprocessing, preprocessor directive, preprocessor directives

Appears in: Lesson 07, Lesson 09

procedural programming

A programming style that organises a solution primarily as procedures or functions operating on data.

Also encountered as: procedural code, procedural

Appears in: Lesson 18, Lesson 19

profiler

A tool that measures where a program spends time or uses resources so performance work can be guided by evidence.

Also encountered as: profilers, profiling, profile

Appears in: Lesson 01, Lesson 10, Lesson 15

program

A set of instructions and associated data arranged so a computer can perform a task.

Also encountered as: programs, computer program, computer programs

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 21, Lesson 23, Lesson 24

programming statement

A complete instruction in source code, such as a declaration, expression statement, branch, loop or return.

Also encountered as: programming statements, program statements

Additional course reference term.

property-based testing

Testing that generates many inputs and checks general properties that should always hold instead of relying only on a few hand-written examples.

Also encountered as: property-based test, property-based tests, property test, property tests

Additional course reference term.

public, protected and private

C++ access levels: public members are available through the class interface, protected members are available to the class and its derived classes, and private members are restricted to the class and its friends.

Also encountered as: public, protected, private

Appears in: Lesson 01, Lesson 07, Lesson 08, Lesson 14, Lesson 15, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

pure virtual function

A virtual function declared with = 0 that makes its class abstract and requires an appropriate derived class to provide the concrete operation.

Also encountered as: pure virtual, pure virtual functions

Appears in: Lesson 18, Lesson 21

RAII

Resource Acquisition Is Initialization: a C++ technique that ties a resource's lifetime to an object, acquiring it during construction and releasing it automatically during destruction.

Also encountered as: Resource Acquisition Is Initialization

Appears in: Lesson 01, Lesson 03, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 23, Lesson 24

raw pointer

A built-in C++ pointer with no automatic ownership behaviour. It may observe an object, but ownership must be established separately.

Also encountered as: raw pointers

Appears in: Lesson 03, Lesson 14, Lesson 15, Lesson 16, Lesson 19, Lesson 21, Lesson 24

recursion

A technique in which a function calls itself directly or indirectly, normally with a base case that ends the repetition.

Also encountered as: recursive, recursive call, recursive calls

Appears in: Lesson 06

ref-qualifier

A trailing & or && on a member function that restricts whether it may be called on lvalue or rvalue objects.

Also encountered as: ref-qualifiers, reference qualifier, reference qualifiers

Appears in: Lesson 19, Lesson 21

release build

A build configured for delivery and performance, usually with optimisation enabled and less debugging information than a debug build.

Also encountered as: release builds, release mode

Appears in: Lesson 01

resource

Something a program must acquire and release correctly, such as memory, a file, socket, lock or graphics handle.

Also encountered as: resources, resource handle, resource handles

Appears in: Lesson 01, Lesson 11, Lesson 15, Lesson 16, Lesson 18, Lesson 24

return type

The type of value a function promises to produce for its caller. The type void indicates that no value is returned.

Also encountered as: return types

Appears in: Lesson 04, Lesson 05, Lesson 06, Lesson 16, Lesson 21, Lesson 23

return value

The value produced by a function and delivered to its caller by a return statement.

Also encountered as: return values, returned value, returned values

Appears in: Lesson 04, Lesson 05, Lesson 06, Lesson 12, Lesson 13, Lesson 16, Lesson 19, Lesson 21, Lesson 22, Lesson 23

Rule of Three, Five and Zero

C++ guidance for resource-managing classes: related copy, move and destruction operations must be considered together, while well-designed RAII members often let a class declare none of them itself.

Also encountered as: Rule of 3, Rule of 5, Rule of 0, Rule of 3 / 5 / 0, rule of three, rule of five, rule of zero

Appears in: Lesson 15, Lesson 18, Lesson 23, Lesson 24

runtime

The period when a compiled program is executing, as opposed to compile time.

Also encountered as: run time, run-time, runtime behaviour, runtime behavior

Appears in: Lesson 03, Lesson 08, Lesson 09, Lesson 10, Lesson 12, Lesson 13, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 21, Lesson 23, Lesson 24

runtime type information

C++ information that allows certain type checks and casts within polymorphic class hierarchies while the program runs, commonly abbreviated RTTI.

Also encountered as: RTTI, type query, type queries

Appears in: Lesson 21

rvalue

A C++ expression category commonly associated with temporary values or objects whose resources may be moved from.

Also encountered as: rvalues, rvalue expression, rvalue expressions

Appears in: Lesson 06, Lesson 17, Lesson 24

sanitizer

A compiler-assisted runtime checker that detects classes of faults such as invalid memory access, undefined behaviour or data races.

Also encountered as: sanitizers, AddressSanitizer, UndefinedBehaviorSanitizer

Appears in: Lesson 01, Lesson 14, Lesson 15, Lesson 24

scope

The region of source code where a declared name is visible and can be used.

Also encountered as: scopes, lexical scope

Appears in: Lesson 02, Lesson 03, Lesson 04, Lesson 08, Lesson 09, Lesson 10, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 24

segmentation fault

A runtime failure raised by the operating system when a program attempts an invalid memory access.

Also encountered as: segfault, segmentation faults

Additional course reference term.

sentinel

A special value or condition used to mark the end of input or control repetition.

Also encountered as: sentinel value, sentinel values, sentinel-controlled

Appears in: Lesson 02, Lesson 05, Lesson 10, Lesson 11

SFINAE

Substitution Failure Is Not An Error: an older C++ template technique in which unsuitable candidates are removed during substitution rather than causing immediate compilation failure.

Also encountered as: Substitution Failure Is Not An Error

Appears in: Lesson 23

short-circuit evaluation

Evaluation of && or || that stops as soon as the final Boolean result is known, so the right operand may not execute.

Also encountered as: short-circuit, short circuit, short-circuiting

Appears in: Lesson 11, Lesson 12, Lesson 22

side effect

A change caused while evaluating an expression, such as modifying an object, performing input/output or altering external state.

Also encountered as: side effects, side-effect, side-effects

Appears in: Lesson 04, Lesson 06, Lesson 10, Lesson 12, Lesson 13

SIMD

Single Instruction, Multiple Data: processor facilities that apply one operation to several data values at once.

Also encountered as: SIMD-friendly, vector instruction, vector instructions

Appears in: Lesson 01

smart pointer

An RAII class that stores a pointer and manages or expresses ownership, such as std::unique_ptr, std::shared_ptr or std::weak_ptr.

Also encountered as: smart pointers, unique_ptr, shared_ptr, weak_ptr

Appears in: Lesson 03, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 19, Lesson 21, Lesson 23, Lesson 24

software build

The process, or resulting output, of turning source files and resources into a runnable program.

Also encountered as: builds, build process, program build, program builds

Appears in: Lesson 01, Lesson 07, Lesson 09

source file

A file containing program source text. A C++ implementation file commonly uses the .cpp extension.

Also encountered as: source files, implementation file, implementation files

Appears in: Lesson 07, Lesson 08

specialisation

A custom template definition used for particular template arguments instead of the primary template.

Also encountered as: specialization, specialisations, specializations, specialise, specialize

Appears in: Lesson 20, Lesson 21, Lesson 23

stack

In this course's memory context, the stack is the automatically managed region commonly used for function call records and local objects. The word can also name a last-in, first-out data structure.

Also encountered as: stack memory, call stack

Appears in: Lesson 01, Lesson 03, Lesson 05, Lesson 09, Lesson 14, Lesson 15, Lesson 16, Lesson 24

standard library

The portable set of types, functions and facilities supplied by the C++ standard, including containers, algorithms, strings and input/output streams.

Also encountered as: C++ standard library, std library

Appears in: Lesson 07, Lesson 09

state

The collection of values that describes a program or object's condition at a particular moment.

Also encountered as: program state, object state, states

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

state trace

A step-by-step record of selected variable values as a program executes, used to explain or debug changes in program state.

Also encountered as: state traces, variable trace, variable traces, trace table, trace tables

Additional course reference term.

static

A C++ keyword with context-dependent meanings, including static storage duration, internal linkage and class members shared by all objects of a class.

Also encountered as: static keyword, static member, static members

Appears in: Lesson 01, Lesson 08, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 21, Lesson 24

static local variable

A variable declared inside a function with local scope but static storage duration, so its value persists between calls.

Also encountered as: static local, static locals

Appears in: Lesson 16

static polymorphism

Compile-time selection of behaviour for different types, commonly implemented with templates rather than virtual dispatch.

Also encountered as: compile-time polymorphism

Appears in: Lesson 18, Lesson 19, Lesson 21

static storage duration

A lifetime category for objects that exist for the duration of the program.

Also encountered as: static storage

Appears in: Lesson 16

static type

The type known for an expression at compile time, determined from its declaration and the language's type rules.

Also encountered as: compile-time type

Appears in: Lesson 19, Lesson 21, Lesson 23

storage duration

The C++ category that determines how long an object's storage lasts, including automatic, static, thread and dynamic storage durations.

Also encountered as: storage lifetime

Appears in: Lesson 03, Lesson 14, Lesson 16

stream

An abstraction representing a sequence of data flowing into or out of a program, such as a file stream or standard output stream.

Also encountered as: streams, input stream, output stream

Appears in: Lesson 02, Lesson 05, Lesson 09, Lesson 11, Lesson 13, Lesson 14, Lesson 18, Lesson 20, Lesson 22, Lesson 24

stream insertion and extraction

The conventional use of operator<< to write values to a stream and operator>> to read values from a stream.

Also encountered as: stream insertion, stream extraction, stream operator, stream operators

Appears in: Lesson 05, Lesson 09, Lesson 22

string

A sequence of characters representing text. Modern C++ commonly uses std::string for owned text.

Also encountered as: strings, character string, character strings

Appears in: Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 11, Lesson 12, Lesson 13, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 22, Lesson 23, Lesson 24

string_view

A lightweight, non-owning view of a character sequence. The viewed characters must remain alive for as long as the view is used.

Also encountered as: string view, string views

Appears in: Lesson 06, Lesson 16, Lesson 18, Lesson 24

switch statement

A control-flow statement that selects a labelled case according to the value of an integral or enumeration expression.

Also encountered as: switch, switch statements

Appears in: Lesson 08, Lesson 11, Lesson 12, Lesson 13, Lesson 17, Lesson 21

symbol

A named entity represented in compiled output so the linker or debugger can identify functions, objects and other program elements.

Also encountered as: symbols, symbol name, symbol names

Appears in: Lesson 07, Lesson 08, Lesson 22

template argument

A concrete type, value or template supplied for a template parameter when a template is used or instantiated.

Also encountered as: template arguments

Appears in: Lesson 23

template argument deduction

The compile-time process by which C++ infers template arguments from a function call or other context.

Also encountered as: template deduction, type deduction, deduction

Appears in: Lesson 02, Lesson 23

template parameter

A placeholder declared by a template and replaced by a template argument when the template is used.

Also encountered as: template parameters

Appears in: Lesson 23

test case

A defined input, setup and expected result used to check one aspect of software behaviour.

Also encountered as: test cases, test-case, test-cases

Appears in: Lesson 03, Lesson 11, Lesson 12

testing

Executing or analysing software in a controlled way to obtain evidence about its behaviour and discover faults.

Also encountered as: tests, test

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

three-way comparison

The C++20 <=> operator, sometimes called the spaceship operator, which expresses whether one value is less than, equal to or greater than another.

Also encountered as: spaceship operator, three way comparison

Appears in: Lesson 22

time complexity

How an algorithm's number of computational steps grows with input size.

Also encountered as: running-time complexity, runtime complexity

Additional course reference term.

translation unit

A C++ source file after preprocessing, including the contents of its included headers, treated as one unit by the compiler.

Also encountered as: translation units

Appears in: Lesson 07, Lesson 08, Lesson 09, Lesson 20, Lesson 23

type

A classification that determines what values an object may hold, how they are represented and which operations are permitted.

Also encountered as: types, data type, data types

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

type safety

The extent to which a language and program prevent values from being used through incompatible types.

Also encountered as: type-safe, type safe

Appears in: Lesson 09

undefined behaviour

A situation for which the C++ standard imposes no requirements on what the program does. Once reached, results cannot be reasoned about reliably.

Also encountered as: undefined behavior, UB

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 14, Lesson 15, Lesson 17, Lesson 19, Lesson 21, Lesson 24

unit test

A focused automated test of a small unit of behaviour, usually a function or class, in controlled conditions.

Also encountered as: unit tests, unit testing

Appears in: Lesson 01, Lesson 02, Lesson 05, Lesson 06, Lesson 07, Lesson 10, Lesson 15, Lesson 18, Lesson 22, Lesson 24

unnamed namespace

A namespace without a name that gives its declarations internal linkage within the current translation unit. It is also called an anonymous namespace.

Also encountered as: anonymous namespace, anonymous namespaces, unnamed namespaces

Appears in: Lesson 08

use-after-free

Accessing an object through a pointer or reference after that object's lifetime has ended and its storage has been released.

Also encountered as: use after free, use-after-delete

Appears in: Lesson 03, Lesson 14, Lesson 15, Lesson 24

using declaration

A C++ declaration that brings one specific name into the current scope, such as using std::cout.

Also encountered as: using declarations

Appears in: Lesson 08

using directive

A C++ directive such as using namespace std that makes all names from a namespace candidates for unqualified lookup in a scope.

Also encountered as: using namespace, using directives

Appears in: Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 07, Lesson 08, Lesson 09

value

The information represented by an expression or stored in an object at a particular point during execution.

Also encountered as: values

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 10, Lesson 11, Lesson 12, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 22, Lesson 23, Lesson 24

variable

A named object whose stored value can be read and, unless restricted, changed while the program runs.

Also encountered as: variables

Appears in: Lesson 01, Lesson 02, Lesson 03, Lesson 06, Lesson 07, Lesson 08, Lesson 10, Lesson 11, Lesson 13, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 23

vector

In the C++ library, std::vector is a resizable contiguous sequence container. In game mathematics, vector can instead mean a quantity with components such as position or direction.

Also encountered as: vectors, std::vector

Appears in: Lesson 03, Lesson 04, Lesson 05, Lesson 06, Lesson 07, Lesson 08, Lesson 09, Lesson 10, Lesson 14, Lesson 15, Lesson 16, Lesson 17, Lesson 18, Lesson 19, Lesson 20, Lesson 21, Lesson 24

virtual destructor

A destructor declared virtual in a base class so deleting a derived object through a base pointer invokes the complete derived destruction sequence.

Also encountered as: virtual destructors

Appears in: Lesson 19, Lesson 21, Lesson 24

virtual function

A member function whose overriding implementation is selected at runtime according to the dynamic type of the object.

Also encountered as: virtual functions, virtual method, virtual methods

Appears in: Lesson 19, Lesson 21

virtual memory

The operating system's abstraction that gives a process its own address space and maps virtual addresses to physical memory or backing storage.

Also encountered as: virtual address, virtual addresses, physical memory

Appears in: Lesson 10, Lesson 14

vtable

A common compiler implementation structure containing virtual-function targets for a polymorphic class. The C++ language specifies behaviour, not this exact representation.

Also encountered as: virtual table, virtual function table, vtables

Appears in: Lesson 18, Lesson 19, Lesson 21

watch window

A debugger view that displays selected expressions or variables and updates their values as execution is inspected.

Also encountered as: watch windows, watch list, watch lists

Appears in: Lesson 01, Lesson 02, Lesson 11

while loop

A loop that checks its condition before each iteration and repeats while that condition remains true.

Also encountered as: while loops, while-loop, while-loops

Additional course reference term.

wild pointer

An uninitialised pointer containing an indeterminate address rather than a known valid address or null value.

Also encountered as: wild pointers, uninitialised pointer, uninitialized pointer

Appears in: Lesson 14

worst-case complexity

An upper bound on an algorithm's resource use for the most demanding valid input of a given size.

Also encountered as: worst case, worst-case

Additional course reference term.