394 docs tagged with "c++"

Every material graph you compile from scratch is a new shader permutation the engine has to build, and

Access control (public, private, protected) enables encapsulation by controlling which code can access class members.

Getting an actor to exist on every client, and getting its properties to match the server's values, are

Unreal favors composition over inheritance for actor behavior: instead of a deep class hierarchy for

Every AActor — GameMode, Pawn, a static prop, your custom gameplay actor — goes through the same

Free-function tojson/fromjson only works when you can add a function to the type's own

Initialize arrays and simple structs using brace-enclosed lists without constructors. Concise syntax for multiple members.

AAIController is the non-player analog of APlayerController — it possesses a pawn and is the thing

Every type has an alignment: an address it must start on, always a power of two. char can live

Width and alignment are what turn a stream of values into a readable table, and the defaults differ

Allocators are objects that manage memory allocation for STL containers. They provide a standardized interface for customizing how containers acquire and release memory.

An Animation Blueprint looks like one graph in the editor but is actually two graphs with different jobs,

Arithmetic operators compute numeric results from numeric operands. The surface syntax is

Boost.Asio is not just an async I/O framework — it is also the de-facto C++ networking library.

The assembler converts human-readable assembly code into binary machine code (object files). Each assembly instruction becomes actual CPU instructions.

A prefix typo or an inconsistent folder means a designer searches the Content Browser by scrolling

Every mesh, texture, material, and data table in your project is a UObject serialized into a

This is the difference between a game that loads what it needs and a game that loads everything it

Why this matters

Async logging is not strictly better than sync — it trades tail latency and complexity for

Two separate systems decide what a sound sounds like once it's playing: attenuation decides how loud,

Why this matters

Every gunshot, footstep, and music cue in a UE5 project passes through the same pipeline before it

auto lets the compiler deduce variable types from initializers, reducing verbosity and improving maintainability.

Unreal ships an automated testing framework that runs inside the engine itself — no external test

The messages you want after a failure are almost always the debug-level ones you weren't writing to

spdlog's format strings are fmt's format strings — the same {} mini-language, with the same

A Behavior Tree (UBehaviorTree) is a re-entrant tree of nodes that gets re-evaluated every tick from

CBOR, MessagePack, BSON, UBJSON, and BJData all describe the same data model JSON does — the same

Bitwise operators manipulate the individual bits of integer values. They are the building blocks of

Not every piece of logic belongs on an object. A damage falloff formula, a string-formatting helper, a

"Blueprint is slow" is the kind of claim that's technically true and mostly useless. It's true in the

If boost::sharedptr look almost identical, that is because one is the ancestor

The Boost Graph Library is a generic framework for graph data structures and algorithms. It

Building Boost by hand with b2 works, but on a real team you want builds that

BOOST_FOREACH is a preprocessor macro that provides range-based iteration on compilers that

boost::intrusive_ptr is a reference-counting smart pointer that keeps the count inside the

boost: it owns a single heap object and deletes it when

boost: any number of sharedptr instances can

Boost.Accumulators is a framework for incremental statistical computation. You push data

Boost.Algorithm is a collection of general-purpose algorithms that complement ``. Many

boost::any is a container for a single value of any type, decided at runtime. Where

Boost.Asio is the asynchronous I/O framework at the heart of modern C++ networking and

Boost.Assert is a tiny header-only library that replaces the C standard assert macro with a more

Boost.Atomic provides atomic operations with explicit memory-ordering guarantees — the building

Boost.Beast is a header-only C++ library for HTTP and WebSocket, built directly on top of

boost::bimap is a bidirectional map — a container where both sides are keys. Given a

boost::bind creates a new function object by partially applying arguments to an existing

Boost.Build is Boost's own build system — the toolchain Boost uses to compile itself. Its driver

Boost.Chrono is the duration, time_point, and clock library that directly preceded std::chrono

boost::circular_buffer is a fixed-capacity ring buffer that provides O(1) insertion and

Boost.Config is the quiet foundation almost every other Boost library sits on. Its job is to detect

Boost.Container provides STL-compatible containers that go beyond what the standard library

Boost.Core is the dependency-light foundation of the whole Boost ecosystem: a grab-bag of small,

Boost.Coroutine2 provides stackful coroutines — functions that can suspend and resume while

Boost.Date_Time provides date and time types for C++:date),

boost::dll provides portable shared-library loading — open a .so, .dll, or .dylib at

Boost.Fiber provides user-space cooperative threads (fibers). A fiber looks like a thread — it

boost::filesystem provides portable file and directory operations — path manipulation,

boost::format gives you type-safe, positional string formatting using a printf-inspired

boost::function is a polymorphic function wrapper — it can store and invoke any callable

Boost.Fusion is a library for working with heterogeneous collections — containers whose elements

Boost.Geometry is a computational geometry library that works with points, linestrings,

Boost.Hana is a modern C++14 metaprogramming library that replaces the template-heavy

Boost.Interprocess provides portable inter-process communication (IPC) primitives: shared

Boost.Intrusive provides containers where the link/hook metadata lives inside the elements

boost::iostreams is a framework for building filtering streams — chains of sources, sinks, and

Boost.Iterator provides tools for building and adapting iterators without the boilerplate that

Boost.JSON is a header-only, RFC 8259 compliant JSON library added in Boost 1.75. It provides

boost::lexical_cast(source) converts between text and almost any type with a single, uniform

Boost.Lockfree provides lock-free and wait-free data structures — concurrent queues and

Boost.Log is a structured logging framework for C++ that separates the concerns of producing

Boost.Math is a comprehensive mathematics library that goes far beyond what `` provides.

The Boost Metaprogramming Library (MPL) is the original framework for compile-time programming

Boost.MultiIndex lets you build a single container with multiple simultaneous indexes over the

Boost.Multiprecision provides integer, rational, and floating-point types with arbitrary or

boost::numeric_cast(source) is a checked numeric conversion that throws

boost::optional represents a value that may or may not be present — a nullable value that does

Boost.Phoenix is a functional-programming toolkit for C++ that lets you build function objects

Boost.Polygon is a computational geometry library focused on integer-coordinate polygon

Boost.Pool is a fast memory allocator specialised for handing out many objects of the same fixed

Boost.Preprocessor is a header-only library that turns the C preprocessor — a blunt text-substitution

boost::process provides cross-platform subprocess management — launch child processes, capture

boost::program_options parses command-line arguments, config files, and environment variables

Boost.PropertyTree provides a tree-shaped data structure (ptree) with parsers and generators

Boost.Random provides a framework of random number engines and distributions that separate

Boost.Range replaces iterator pairs with range objects and provides range adaptors —

boost::rational represents an exact fraction as a numerator/denominator pair. Every

boost::regex is a regular expression engine for C++ that supports Perl and POSIX syntax. It

Boost.Serialization converts C++ objects to and from a sequence of bytes — serialization and

Boost.Signals2 is a header-only implementation of the signal/slot mechanism — a type-safe,

Boost.Spirit is a parser and generator framework that lets you write grammars directly in C++

Boost.Stacktrace lets you capture and print call stacks programmatically from within a C++

boost::string is a collection of generic string algorithms — case conversion,

boost::system provides the error_code and error_category framework — a structured, extensible

Boost.Test is a unit testing framework for C++ that provides test case definition, rich

Boost.Thread provides portable threading primitives — threads, mutexes, condition variables, futures,

boost::tokenizer breaks a string into tokens using pluggable separator functions. It

Boost.TypeTraits provides a collection of compile-time type introspection and type

Boost.uBLAS (micro Basic Linear Algebra Subprograms) provides vector and matrix types with

Boost.Units brings compile-time dimensional analysis to C++. It wraps numeric values in

Boost.Unordered provides hash-based associative containers — unorderedmap, unorderedset,

Boost.Utility is one of the oldest corners of Boost: a historical collection of miscellaneous

Boost.UUID is a small, header-only library for creating and manipulating Universally Unique

boost: a single object that holds a

The dropdown in Visual Studio's toolbar (DebugGame Editor, Development Editor, Shipping, ...)

Build systems automate compilation, dependency management, and linking. They track changes and rebuild only what's necessary, making large C++ projects manageable.

What are Build Types?

Almost every shipped Unreal project is built on the same shape: a small number of C++ classes that

C++ syntax defines how code is written and structured. Understanding basic syntax is essential for writing valid C++ programs.

The C++ compilation process transforms source code into executable binary through four main stages: preprocessing, compilation, assembly, and linking.

The C++ ecosystem encompasses compilers, build systems, package managers, IDEs, libraries, and testing frameworks. Understanding this landscape is crucial for effective C++ development.

Every doc in this section assumes a specific split: systems and data live in C++; composition and

Calling conventions define how functions receive parameters and return values at the assembly level - register usage, stack cleanup, and parameter passing order.

Attach a UCameraComponent straight to a character's mesh and two problems show up immediately: the

Chaos is Unreal 5's physics and destruction engine, replacing PhysX. Most gameplay code never calls into

UCharacterMovementComponent is the single biggest reason ACharacter is worth using over a bare

std::milliseconds knows it's

The chrono library provides type-safe time utilities for durations, time points, and clocks. It's designed to prevent common time-related bugs through strong typing.

This page explains how the class features you write — members, virtual functions, inheritance —

Class templates create generic classes that work with different types. Think std::unique_ptr - same class, different types.

What are Variables?

File Anatomy

Every "why does my trace hit nothing" or "why does my character walk through a wall" bug traces back to

Terminal color is a formatting concern, and fmt handles it with the same type-safe API used

Everything covered so far in this folder — Details customizations, factories, Editor Utility Widgets —

Nearly every fmt bug that reaches production is a lifetime bug or a

CommonUI is Epic's plugin for controller-friendly, platform-portable UI, built on top of UMG rather than

Every C++ JSON library parses the same grammar into more or less the same tree shape. Where they

The C++ logging libraries you'll actually run into differ less in "can it log" and more in how much

The two incumbents fail in opposite directions — printf trades safety for speed and brevity,

The compilation phase translates preprocessed C++ code into assembly language. This is where syntax checking, semantic analysis, optimization, and code generation happen.

The whole point of replacing printf is that a wrong format string shouldn't be a runtime surprise.

A runtime level check is cheap, but it isn't free — it's still a branch and, on the disabled path,

Concepts are named requirements for template arguments that replace SFINAE and enable_if with readable constraints. Requires expressions are the building blocks that check if code compiles at compile-time.

Conditionals choose a branch at runtime. Modern C++ adds two things worth knowing beyond the basic

Unreal doesn't have one settings file — it has a layered stack of .ini files that get merged at engine

Console output is the default destination because it's the one that always exists — no file

CV-qualifiers (const and volatile) modify type behavior. const prevents modification; volatile prevents compiler optimization.

const with pointers creates three distinct scenarios. Understanding the difference prevents bugs and documents intent.

constexpr indicates values or functions can be evaluated at compile-time, enabling compile-time computation and optimization.

Constructors initialize objects and allocate resources. Destructors clean up when objects are destroyed. Together they enable RAII (Resource Acquisition Is Initialization).

The first cook on a fresh machine can take hours; the same project's cook on a machine with a warm

Copy creates a duplicate of an object. Move transfers ownership of resources from one object to another. Understanding when each happens is crucial for performance and correctness.

A coroutine is a function that can suspend itself, hand control back to its caller, and later

A crash on a player's machine, with no debugger attached and no way to reproduce it locally, is only

Construction is where the library's convenience is loudest — you can build a document out of

There are two ways to make a logger: the factory helpers, which build a sink and register the logger

Cross-compilation builds executables for a different platform (target) than the one running the compiler (host). Essential for embedded systems, mobile development, and deploying to different architectures.

json isn't a concrete class — it's using json = basic_json;, one particular instantiation of

A UDataAsset subclass is usable the moment you compile it — but "usable" and "designer-friendly" are

Extend smart pointers to manage any resource requiring special cleanup beyond delete. Enable RAII for files, handles, connections, locks - anything needing cleanup.

When no built-in pattern flag carries the field you need — a request id, a thread name, a tenant —

Wall-running, climbing, grappling, and swimming-that-isn't-MOVE_Swimming all eventually lead you to

Why this matters

A custom sink is the supported way to send logs anywhere spdlog doesn't already reach — an in-memory

Collision and physics tell you that something touched, but they don't know what "damage" means — that's

Subclassing gets you far — see C++ base, Blueprint derived — but it

Unreal's containers, reflection system, and string types don't display usefully in a stock debugger —

decltype deduces the type of an expression, preserving references and const qualifiers exactly.

decltype(auto) (C++14) combines auto convenience with decltype precision - deduces type while preserving references and const.

Replication and RPCs describe how actors talk to each other once a game session exists. Dedicated

Object created without explicit initializer. Behavior depends on type and storage duration. Dangerous for fundamental types in local scope.

Delegates are Unreal's answer to "call this function later, without the caller knowing what type owns

The project's own README states its goals plainly: intuitive syntax, trivial integration, and

Three decisions explain almost every API in spdlog: formatting is delegated to fmt, sinks are the

Most projects start single-player, or single-player-first with multiplayer as a maybe-someday. That's a

The default Details panel — the one every UCLASS and USTRUCT gets for free — is a generic property

C++ evolves through standardized versions released approximately every three years. Each standard adds features, fixes issues, and modernizes the language while maintaining backward compatibility.

C++ supports two forms of polymorphism: dynamic (runtime, using virtual functions) and static (compile-time, using templates). Each has different trade-offs.

IDetailCustomization and a hand-rolled Slate widget are the right tool when you're extending an

Every custom editor tool you write — a Details panel customization, a custom asset factory, an Editor

There are four ways to read a key or index out of a json, and they disagree on what happens when

Every later doc in this section assumes you can place a new piece of knowledge somewhere on a map.

Why this matters

Enhanced Input replaced the old InputComponent axis/action mapping system as UE5's standard input

A Behavior Tree decorator can ask "is there a target?" but it can't cheaply ask "which of these fifty

Unreal C++ has a house style, and it's more than cosmetic: the type-prefix convention (U, A, F,

fmt's errors arrive in two flavours: a wall of template output at compile time, and a

Every failure in this library — a malformed parse, a wrong-type access, a missing key, an invalid

Core Commands

A target is the unit of modern CMake. Once addexecutable() (or addlibrary()) creates one,

Every specifier you attach to a UPROPERTY or UFUNCTION is a decision about who gets to see and

Expressions produce values; statements perform actions. Understanding the distinction is fundamental to C++ programming.

What is ExternalProject?

What is FetchContent?

The simplest durable destination — and the one whose failure modes (permissions, unbounded growth,

The filesystem library (C++17) provides portable facilities for manipulating files and directories. It replaces platform-specific APIs and C-style file operations with a modern, type-safe interface.

CMake offers three, in rough order of preference:

A log line that's still sitting in a buffer when the process dies never existed, as far as anyone

Fold expressions provide a concise way to apply operators to variadic template parameter packs. They eliminate the need for recursive template patterns.

Everything after the : in a replacement field is one small grammar. Learn it once and it applies to

A format string is a template with holes in it. Everything else in fmt — the spec grammar, custom

Extensibility is the thing printf can never have. A formatter specialization makes your own

Unreal doesn't use std::string. It has three distinct string types — FString, FName, and

Full specialization provides a completely custom implementation for specific template arguments. It's like saying "for this exact type, use this completely different code."

Function overloading allows multiple functions with the same name but different parameters. The compiler selects the best match based on arguments.

Function templates let you write one function that works with different types. The compiler generates specific versions for each type you use.

C++ provides built-in fundamental types for integers, floating-point numbers, characters, and booleans.

GameMode gets destroyed and recreated on every level load; Pawns die and respawn; even

AGameModeBase and AGameStateBase look like they should be one class — they're set up together, they

Why this matters

Why this matters

Why this matters

Why this matters

Every gameplay tutorial throws GameMode, PlayerController, Pawn, and PlayerState at you in the

Why this matters

UObjects are not managed with new/delete or reference counting — they're managed by a tracing

Why this matters

Why this matters

Why this matters

spdlog's globals — the registry, the default logger, the registry-wide setters — are what make the

C++11 refined value categories into five types: lvalue, prvalue, xvalue, glvalue, and rvalue. Understanding these enables perfect forwarding and move semantics.

goto jumps unconditionally to a label in the same function. It exists, it is occasionally the

Why this matters

One of the first practical questions every Boost user hits is: do I need to link anything? The answer

fmt's runtime cost is settled — it's fast, and that doesn't change based on how you build it. Its

Headers (.h, .hpp) contain declarations that are shared across multiple source files. The #include directive copies header contents into source files during preprocessing.

Boost was born in 1998, the same year the first ISO C++ standard (C++98) was ratified. That timing is

AHUD is the older, canvas-based counterpart to UMG: a per-player actor whose job is drawing directly

Motion Matching aside, most of the "make the feet actually touch the ground" and "reuse this animation

The import dialog you click through in five seconds sets compression, LOD, and streaming behavior that

pragma once

Inheritance lets you create new classes based on existing ones, reusing code and establishing "is-a" relationships. Derived classes inherit members from base classes and can add new functionality or override existing behavior.

inline suggests the compiler replace function calls with function body, eliminating call overhead. Modern compilers decide automatically.

The iostream library provides facilities for input/output operations through streams. It's a type-safe, extensible alternative to C's printf/scanf.

fmt can be dropped into a project as header-only, with no build step at all, or built and linked as

There isn't one right way to add nlohmann/json to a project — there's a spectrum from "copy one

The header-only default is what makes spdlog trivial to adopt — copy a directory, add an include

Everything downstream — compile times, IntelliSense accuracy, whether Live Coding works at all —

There is no single "install Boost" button, and that is mostly fine: because the majority of Boost is

Installation Methods

Iterating a json container gives you values, never key-value pairs — a design choice inherited

Iterators are the glue between containers and algorithms. They provide a uniform interface for traversing and accessing elements in different container types, enabling generic algorithms.

RFC 6901 (JSON Pointer) and RFC 6902 (JSON Patch) give you standardized addressing and diffing for

Tokens are the smallest units of a C++ program. Keywords are reserved words with special meaning that cannot be used as identifiers.

Lambdas (C++11) are anonymous functions that can capture variables from surrounding scope, enabling functional programming patterns and convenient callbacks.

Why this matters

This knowledge base is reference material, not a tutorial — it assumes you're building something and

Why this matters

This page covers creating libraries and attaching their usage requirements (include dirs,

Why this matters

Understanding Library Linking

The linker combines multiple object files and libraries into a single executable, resolving symbol references and assigning final memory addresses.

The single biggest iteration-speed lever in Unreal C++ development is not touching the "restart the

Every piece of text a player reads has to survive translation into other languages without a code change,

Levels aren't one filter, they're two: a runtime one that lives per logger (and optionally per sink),

Loggers are shared_ptr-owned. The registry holds one reference, you typically hold another (or

Unreal doesn't use C++ exceptions — throwing is disabled across the engine, and Epic's own guidance is

&&, ||, and ! combine boolean conditions. The detail that matters is short-circuit

Four looping forms cover every case. The decision is rarely about capability — they are mostly

Why this matters

Every C++ expression has a type and a value category. Lvalues have persistent storage; rvalues are temporaries.

Makefiles define rules for building projects using the Make build system. They specify dependencies and commands to compile source code incrementally.

This section has 18+ folders behind it by the time it's complete, and none of them are meant to be

Why this matters

Data arranged at addresses that are multiples of its size. Required for correctness on some architectures, critical for performance on all.

Why this matters

Understanding how C++ programs use memory is fundamental to writing efficient, safe code. Memory is divided into distinct regions with different characteristics and management strategies.

fmt::memory_buffer is the container fmt itself uses internally to build formatted output — a small

"Combine two documents" turns out to mean three different, non-interchangeable operations in this

MetaSounds replace Sound Cues as UE5's procedural audio graph system. Where a Sound Cue graph runs once

The two APIs are close enough that migration is mostly mechanical in either direction — the

Modules are C++20's replacement for the textual #include model. Instead of the preprocessor

A module is the compilation unit; a plugin is the distribution unit. Confusing the two leads to two

UAnimMontage is how you play a one-off animation — an attack, a reload, a hit react — outside the

Motion Matching flips the animation-authoring problem around: instead of hand-building a state machine

If a networked character waited for a server round-trip before every step responded on screen, the game

One logger, several destinations — this is the standard shape for a real application: everything to

Multiple inheritance allows a class to inherit from multiple base classes. This enables combining functionality but introduces complexity, especially the diamond problem.

Name mangling (name decoration) encodes C++ function signatures into unique symbol names for the linker. This enables function overloading and namespaces while maintaining linkage compatibility.

Why this matters

Every AI move-to call, every EQS pathfinding test, every MoveTo on an AAIController ultimately

Every networking bug in Unreal traces back to one question: which machine actually owns this piece of

Manual dynamic memory management in C++. Allocates on heap, requires explicit deallocation. Modern C++ prefers smart pointers.

noexcept specifies that a function won't throw exceptions, enabling optimizations and stronger guarantees.

JSON has exactly one number type — an arbitrary-precision decimal, syntactically. C++ has several,

fmt is locale-independent by default, and that is a feature, not an oversight — you opt in to

Object files (.o, .obj) are compiled but not yet linked binary files containing machine code, data, and metadata for the linker.

Object lifetime spans from construction to destruction. Understanding lifetime is critical for memory safety, RAII, and avoiding undefined behavior.

Object slicing occurs when you copy a derived class object to a base class object. The derived parts are "sliced off" and lost.

Operator overloading lets your types reuse built-in operator syntax — a + b, v[i], os << x —

Precedence decides which operator binds first when an expression mixes operators;

Why this matters

A codebase with hundreds of operator<< overloads doesn't need rewriting to adopt fmt. The ostream

fmt::string that you often immediately throw away — append it to

The async queue is bounded, so at some point the producer (your application logging quickly) outruns

Boost is a collection of peer-reviewed, portable C++ libraries that sit one layer above the

A structured reference for modern C++ (C++17/20/23): from the toolchain that turns text into a

CMake is a build-system generator: you describe your project once in CMakeLists.txt, and CMake

fmt is a fast, type-safe formatting library with Python-style replacement fields — {} holes in a

nlohmann/json — formally "JSON for Modern C++" — is a

spdlog is a very fast, header-only-by-default C++ logging library built on top of

Building your project in Visual Studio and packaging it are different pipelines that happen to share a

Parsing is the boundary between untrusted text and typed data. Every way into a json value from

Partial specialization lets you specialize templates for a pattern of types, not just one specific type. It's like "for all pointer types" or "for all pairs of same types."

The pattern controls the line around your message — timestamp, level, logger name, thread id — and

ACharacter is a subclass of APawn, and in practice most projects reach for ACharacter by default

The library's defaults are tuned for ergonomics, not throughput, and most of the performance

fmt is fast for structural reasons, not micro-optimizations — knowing which ones lets you tell when

A single simulating rigid body falls, bounces, and rolls, but it can't hinge, swing on a chain, or hold a

Constructs objects in pre-allocated memory without allocating. Separates construction from allocation for custom memory management.

APlayerController and APlayerState both represent "the player" in some sense, and both persist

Pointer arithmetic navigates contiguous memory with automatic scaling by type size. Essential for arrays but dangerous without bounds checking.

Positional and named arguments exist for the same reason: the order of the holes in a format string

Why this matters

The preprocessor is a text manipulation tool that runs before compilation. It handles #include, #define, #ifdef, and other directives, producing pure C++ code for the compiler.

Why this matters

C++ programs consist of one or more source files containing declarations, definitions, and the required main() function.

Knowing which folders in a project are source of truth and which are disposable build output is

The default logger exists so that adding logging to a program is one include and one call. Everything

RAII is a fundamental C++ idiom where resource lifetime is tied to object lifetime. Resources are acquired in constructors and released in destructors, ensuring automatic cleanup and exception safety.

Ranges (C++20) is a modern library that provides composable, lazy-evaluated operations on sequences. It replaces traditional iterator pairs with range objects and introduces views for efficient data transformation pipelines.

Printing a container is the single most common debugging need in C++, and it's the one thing the

A pointer is a variable that stores a memory address, allowing indirect access to other variables.

When template type deduction creates "reference to reference", C++ applies collapsing rules. This enables perfect forwarding.

A reference is an alias - another name for an existing object. Unlike pointers, references cannot be null, must be initialized, and cannot be reseated.

std::format is fmt, standardised. P0645 took fmt's design into the C++20 standard library almost

Every topic in this folder — debugging setup, automated tests, config layering, save versioning, packaging,

The default replication path re-evaluates, for every connection, whether every replicated actor is still

Replicated properties are good at "this value changed and stays changed." They're the wrong tool for

Why this matters

Why this matters

Two different answers to "the log file cannot grow forever": rotate by size whenever the current file

These rules tell you which special member functions to define based on your class's resource management needs.

A save file written today has to keep loading correctly after every future patch, DLC, and refactor for

dump() is the inverse of parse() — it turns a json value back into text — and its defaults

Writing tojson/fromjson by hand for a plain data struct is mostly boilerplate — list the

SFINAE (Substitution Failure Is Not An Error) is a fundamental C++ template mechanism that enables conditional template compilation. std::enable_if is the primary tool for applying SFINAE in practice.

Sign and precision are where formatted numbers stop being an aesthetic choice and start being a

Integer types can be signed (negative and positive) or unsigned (only positive). Understanding signedness prevents bugs and overflow issues.

The split of responsibility is deliberate: a logger decides whether to log at all, a sink decides

Every animation system in Unreal — AnimGraph, Control Rig, IK Retargeter, Motion Matching — is built on

Slate is the immediate-feel, C++-only UI framework that UMG is built on top of. You will rarely write raw

Boost.SmartPtr is where modern C++ ownership semantics were invented. Long before std::shared_ptr

Unreal projects mix hand-written C++ with large binary asset files and gigabytes of regenerable

File, line, and function are free only if the call site captures them — which is exactly why they're

Why this matters

State machines and blend spaces are the two workhorse node types inside an AnimGraph — one picks

StateTree is Epic's newer general-purpose execution graph — a hierarchical state machine that borrows

Linking can be static (library code copied into executable) or dynamic (library loaded at runtime). Each has trade-offs in size, deployment, and performance.

Smart pointer with shared ownership via reference counting. Multiple shared_ptrs can own the same object, deleted when last owner destroyed.

Smart pointer with exclusive ownership. Zero overhead, automatic cleanup, move-only semantics. The default choice for dynamic memory.

Non-owning observer of shared_ptr-managed objects. Doesn't increase reference count, enables checking if object still exists.

STL algorithms are generic functions that work with any container through iterators. They provide tested, optimized implementations of common operations. Never write your own sort or search - use the STL!

Containers store collections of objects. The STL provides optimized, well-tested containers for different access patterns and performance needs. Choose the right container for your use case.

Storage duration defines when and where objects are created and destroyed. C++ has four storage durations: automatic, static, dynamic, and thread.

Why this matters

Pointers of different types cannot point to the same memory (with exceptions). Enables compiler optimizations but causes undefined behavior when violated.

C++ provides std::string_view (C++17) for non-owning string references. Rich API for searching, modifying, and converting text data.

Every AnimBP is backed by a UAnimInstance, and pushing gameplay-state gathering into a C++ subclass of

Before subsystems existed, "I need one instance of this system, reachable from anywhere" meant a

When the platform already owns log collection — syslog, the systemd journal, the Windows Event Log —

Understanding Target Properties

Unreal ships its own container library instead of using std::unordered_map, and

Template argument deduction lets the compiler figure out template parameters from function arguments automatically. No need to write func(5) when func(5) works!

One formatting engine, several entry points that differ only in where the characters land — pick

json is one C++ type that behaves like several types at runtime — a tagged union with container

The registry is a global name→logger map. It's what makes spdlog::get("db") work from any file in

DOM parsing — json::parse — builds the entire document in memory before you can look at any of

Unreal interfaces look unlike anything in standard C++ because reflection needs a UObject-derived

Async logging moves formatting and I/O off the calling thread and onto a background pool — the

The library never sees your type definitions — it doesn't know what a Person or an Order is.

Line traces, sweeps, and overlaps are how gameplay code asks the world a question — "what's in front of

A translation unit is a single source file plus all its included headers after preprocessing. It's the basic unit of compilation in C++.

Unreal has two entirely separate ownership systems, and they must never be mixed. UObjects are

This is where the library's "intuitive syntax" goal collides most directly with C++ overload

C++ performs automatic (implicit) and manual (explicit) type conversions. Understanding these prevents bugs and data loss.

Type traits are compile-time tools that query and transform types. They power template metaprogramming and SFINAE, letting you write code that adapts to different types automatically.

The final character of a spec picks a presentation, and the legal set of characters depends on the

UMG (Unreal Motion Graphics) is the widget system almost every UE5 project uses for menus, HUD overlays,

fmt treats char-based strings as UTF-8. That's the right default for nearly every modern codebase,

C++11 brace initialization {} - one syntax for all types. Consistent, safe (prevents narrowing), solves gotchas.

Unreal doesn't use a single monolithic compile step — it compiles per-module, and every module's

Unreal C++ compiles with the same compiler you'd use for any other C++ project, but a meaningful slice

UCLASS, UPROPERTY, and UFUNCTION look like ordinary C++ macros, but the code that makes them

Why this matters

Every gameplay class you write in Unreal — AActor, UActorComponent, your own UMyGameSubsystem

CMake is how most projects consume Boost today. Instead of hand-rolling include paths and -lboost_*

The utilities library provides general-purpose components that don't fit into other categories but are essential for modern C++ development.

Explicitly request zero-initialization for fundamentals, default construction for classes. Safer than default initialization.

Variadic templates accept any number of arguments of any types. They're the foundation for functions like std::make_tuple, printf, and perfect forwarding.

Boost ships as one coordinated release with one version number, even though it is really ~160

Virtual functions enable runtime polymorphism through dynamic dispatch. Understanding how they work (vtables) helps you understand their cost and use them effectively.

Boost is a set of free, open-source, peer-reviewed C++ libraries that extend the standard library

C++ is a general-purpose, compiled programming language that extends C with object-oriented,

Overview

C++ had two bad options for turning values into text: printf, which is fast and terse but

Before this library, JSON in C++ meant one of two things: a hand-rolled recursive-descent parser

For a long time, logging in C++ meant one of two things: hand-rolled iostream chains guarded by

Unreal Engine 5 (UE5) is not one program — it is an editor, a runtime, and a large tree of C++

Why this matters

GetWorld() is one of the first functions every Unreal C++ developer learns, and one of the last ones

Project Structure