C++ Weekly Episodes

This episode extends the previous episode's NTTP bind concept by implementing a custom bind_front that accepts multiple compile-time parameters, not...

This episode explores C++26's enhancement to std::bind_front and std::bind_back that allows passing functions as non-type template parameters (NTTP)...

This episode showcases the most practical application of C++26 reflection: automatic binding of C++ functions to scripting interfaces. Jason...

This episode explores C++26's expansion statements (template for), a powerful new feature that enables compile-time iteration over heterogeneous...

This episode demonstrates a basic reflection technique achievable in C++20 using structured bindings and template metaprogramming. Jason creates a...

This episode examines C++26's define_static_string and define_static_array features (from paper P3491R3) that finally solve a long-standing problem:...

In this milestone 500th episode, Jason reflects on C++ Weekly's journey since March 7, 2016, having never missed a single week. He announces plans to...

This episode explores GCC's built-in stack usage analysis tools, which are invaluable for embedded development and resource-constrained environments....

Jason explains the lifetime rules for automatic (lexically scoped) variables in C++, demonstrating that lifetime begins at declaration and ends at...

Jason provides practical guidance for incrementally adding compiler warnings and static analysis to legacy codebases without being overwhelmed. He...

Jason explains the fundamental differences between stack and heap memory allocation, noting that while the C++ standard doesn't explicitly define...

Jason provides a quick introduction to creating custom formatters for std::format and std::print in C++20/23. He demonstrates the simplest possible...

Jason showcases scnlib, a modern and safe replacement for scanf that provides format-based parsing similar to how lib{fmt} provides formatting. The...

Jason demonstrates how to quickly get started with GUI development in C++ using the FLTK (Fast Light Toolkit) library and his cmake_template project....

Jason explains the subtle but important differences between braced and parenthesized initialization when initializer_list constructors are present....

Jason demonstrates C++17's node handle feature that allows efficient transfer of elements between associative containers (map, set, and their...

Jason compares three approaches for explicitly ignoring return values from [[nodiscard]] functions: std::ignore (C++11), [[maybe_unused]] attribute...

Jason explores C++11's user-defined literals feature, explaining their constraints and best practices. User-defined literals must accept specific...

Jason takes viewers on a personal journey through 35 years of game development projects, from a 1990 animal name game in Commodore 64 BASIC to his...

This episode is an unscripted demonstration of using the Anthropic Claude AI agent to refactor a C++ codebase from using exceptions to std::expected....

This episode explores the fascinating behavior where lambdas can access constexpr local variables without capturing them, effectively creating...

This episode introduces C++26's variadic structured bindings feature, which allows structured bindings to create parameter packs from destructurable...

This episode reveals a surprising aspect of C++ where infinite loops were undefined behavior before C++26, allowing compilers to make aggressive...

This episode provides a practical introduction to the C++ header, which offers superior random number generation compared to the old C...

This episode demonstrates how to create type-safe, RAII-compliant wrappers around C library functions like fopen and fread. Jason shows that most...

This episode explains tail call elimination, a compiler optimization where returning the result of a function call can be transformed into a jump...

This episode reveals a subtle but important issue where calling unqualified abs() on floating-point values in C++ can silently truncate to integer...

This episode explores C++'s 'final' keyword, which can be applied to classes to prevent inheritance or to virtual functions to prevent further...

This episode is a follow-up to a previous exploration of lambdas on the heap, correcting a mistake from the earlier video. Jason demonstrates how to...

This episode introduces Empty Base Optimization (EBO), a compiler technique that optimizes memory layout when inheriting from empty classes. Jason...

This episode introduces C++23's new fold algorithms: fold_left, fold_left_first, fold_right, fold_right_first, fold_left_with_iter, and...

This episode explores the concept of creating C++ lambdas on the heap rather than on the stack. Jason explains how lambdas are closure objects...

This episode demystifies the Load Effective Address (LEA) instruction commonly seen in Compiler Explorer outputs. Jason demonstrates how compilers...

This episode explains how continue and break statements work in C++ loops, including their behavior in range-based for loops. Jason demonstrates that...

This episode explores C++23's new feature that allows declaring static call operators for lambdas. Jason demonstrates how this feature can...

This episode explores C++26's enhancement to the `=delete` functionality, which now allows adding a reason that appears in compiler error messages....

This episode clarifies the distinction between 'requires clauses' and 'requires expressions' in C++20. Jason explains that a requires clause expects...

This episode presents a concise overview of the best approaches for printing output in C++23. Jason recommends using puts() for simple...

This episode explores the significant benefits of using the -fvisibility=hidden compiler flag when creating shared libraries. Jason demonstrates how...

This episode discusses the syntactic equivalence between 'enum class' and 'enum struct' in C++, both of which create scoped enumerations with...

This episode critiques the C++23 std::invoke_r function, highlighting two major issues with its design. Jason demonstrates that invoke_r only works...

This episode discusses a new C++26 feature that allows constructing a std::span from an initializer list, addressing a common pain point in C++...

This episode demonstrates a simple yet powerful technique for printing std::variant values using generic lambdas and std::visit. Jason shows how to...

This episode highlights a safety improvement in C++26 where returning a reference to a temporary value is now a hard compilation error, rather than...

This episode explores C++23's powerful new range formatting capabilities, which enable easy printing of various container types and nested data...

This episode explores C++26's new std::views::concat feature, which allows multiple ranges to be treated as a single concatenated range. Jason...

In this episode, Jason investigates performance differences between GCC and Clang compilers using his Game of Life simulation code. He shares data...

This episode introduces C++26's new saturating math operations, which prevent overflow by clamping results to the maximum or minimum representable...

This episode explores the advantages of std::bitset over alternatives like std::array or std::vector for efficient bit manipulation....

In this episode, Jason reviews two C++ beginner magazines purchased five years apart from different publishers but with remarkably similar content....

This episode examines how Return Value Optimization (RVO) applies to trivial types like arrays, showing significant performance impacts. Jason...

This episode introduces mutation testing with the Mull tool, which helps evaluate test suite quality by modifying source code to create 'mutants' and...

This episode explains the differences between std::invoke and std::apply, two powerful standard library utilities for calling functions. Jason...

This episode demonstrates how to use Valgrind and GDB together to debug memory issues in C++ programs. Jason shows how Valgrind can act as a remote...

This episode explores a confusing aspect of C++ move semantics: how defining a custom destructor silently disables move operations without making...

This episode examines the claim that std::bad_alloc exceptions are obsolete due to modern operating systems' memory overcommitment. Through practical...

This episode responds to criticisms about functional programming features in C++, with Jason demonstrating that C++ has supported functional...

This episode discusses the availability of constexpr math functions in C++. Jason explains how many standard functions only became constexpr...

This episode explores C++23's std::forward_like utility in conjunction with C++23's "deducing this" feature. Jason demonstrates how these features...

This episode explains reference-qualified member functions in C++, which allow different function implementations based on whether the object is an...

This episode highlights ImHex, an open-source, cross-platform hex editor written in C++. Jason demonstrates the tool's extensive feature set,...

This episode explores C++11's thread_local storage duration specifier, which creates variables that are global to individual threads. Jason...

This episode explores GCC's compiler-specific -fimplicit-constexpr flag, which automatically makes inline functions constexpr if they satisfy the...

This episode explores several surprising and lesser-known constexpr behaviors in C++. Jason demonstrates how const integral values initialized with...

In this episode, Jason makes a case against using the .h extension for C++ header files, arguing that it creates confusion about whether a file is...

In this episode, Jason explores the concept of multiple dispatch (also known as multimethods), which allows function calls to be dynamically...

In this episode, Jason revisits the implementation of visitors for std::visit when working with std::variant. He demonstrates three approaches: using...

In this episode, Jason explores the mutable keyword in C++ and explains why it should generally be avoided. He demonstrates how mutable allows member...

In this episode, Jason explores a significant improvement in C++23 that fixes lifetime issues with range-based for loops. He demonstrates how C++20...

In this episode, Jason explores the challenges of obtaining and passing pointers to overloaded functions in C++. He demonstrates that when working...

In this episode, Jason explores a technique for transforming values as they are captured by lambdas using C++20's pack expansion in lambda...

In this episode, Jason explores AdaptiveCpp (formerly Open SYCL), a tool that enables C++ developers to easily offload parallel algorithms to GPUs...

In this episode, Jason explores GCC's new -Wnrvo warning flag which detects when Named Return Value Optimization (NRVO) cannot be applied in...

In this episode, Jason explores the new floating point types introduced in C++23, which are the first new floating point types added to the C++...

This episode addresses common misconceptions about constexpr, explaining that its value extends beyond solving entire problems at compile time. Jason...

This episode explores the combination of Class Template Argument Deduction (CTAD) with Non-Type Template Parameters (NTTP) in C++. Jason explains how...

This episode explains the Small String Optimization (SSO) technique used in standard library classes like std::string, std::any, and std::function to...

This episode introduces parameter pack indexing, a new feature coming in C++26 that simplifies working with template parameter packs. Jason...

This episode introduces std::generator, a key addition in C++23 that provides the first standard library support for coroutines. Jason demonstrates...

This episode demonstrates how to create Python-like generators in C++ without using coroutines or std::generate. Jason shows a clever technique using...

This episode explores how mutable lambdas with captures can function as self-contained state machines. Jason demonstrates this concept first with a...

This episode addresses the potential dangers of using std::string_view, std::span, and other non-owning reference types in C++. Jason demonstrates...

This episode addresses a subtle but potentially serious API design issue with nested types that both provide similar methods. Jason demonstrates how...

This episode provides a comprehensive overview of all C++ attributes from C++11 through C++23. Jason covers the functionality, purpose, and potential...

In this episode, Jason continues his series on modernizing legacy code by upgrading his infix math expression evaluator to C++23. He focuses on...

This episode discusses a common performance issue with wrapper types like std::optional, std::variant, std::pair, std::tuple, std::any, and...

In this episode, Jason continues his series on modernizing code by migrating from C++17 to C++20. He focuses on C++20's enhanced constexpr...

In this episode, Jason highlights what he considers the most important features of C++23. He showcases 13 key additions including std::print/println...

This episode continues Jason's series on modernizing C++ code, focusing on migrating from C++14 to C++17. He demonstrates powerful C++17 features...

This episode explores the Mold linker, a high-performance alternative to traditional linkers for C++ projects. Jason shares his experiments with...

In this episode, Jason Turner continues his series on C++ modernization by migrating code from C++11 to C++14. He demonstrates key C++14 improvements...

In this episode, Jason Turner demonstrates the process of modernizing legacy C++98 code to C++11. He shows various C++11 features like enum class,...

This episode explores C++26's new placeholder variable feature, which allows developers to use an underscore (_) as a variable name when the value is...

This episode explores Unity builds, a compilation technique where multiple C++ source files are concatenated into a single file before compilation....

This episode explores C++23's new [[assume]] attribute, which allows developers to give the compiler hints about guaranteed conditions in their code....

This episode provides a fundamental introduction to C++ exceptions. Jason demonstrates basic exception mechanics including throwing and catching...

This episode explains the critical concepts of alignment and padding in C++ data structures. Jason demonstrates how different data types require...

In this career-focused episode, Jason shares proven strategies for significantly increasing your developer salary through community involvement and...

This episode demonstrates how straightforward it is to implement a constexpr version of std::unique_ptr in C++20, despite it only being officially...

In this extended episode, Jason demonstrates a comprehensive renovation of legacy C++98 code, transforming it into high-quality, maintainable...

This episode explains why pointer arithmetic should be avoided in modern C++ code. Jason demonstrates how easy it is to introduce undefined behavior...

This episode introduces Dogbolt, a free online service similar to Compiler Explorer (Godbolt) but for decompilation rather than compilation. Jason...

This episode explains why developers should prefer writing code that avoids explicit std::move calls. Using a simple example with a custom 'Lifetime'...

This episode introduces CppCoro, a library that simplifies working with C++20 coroutines by providing essential utilities and abstractions that the...

In this entertaining episode, Jason reviews his own C++ code from 1997-1998 university projects, critiquing it from a modern C++ perspective. He...

This episode concludes Jason's mini-series on C++23's new ranges views, focusing on chunk_view and stride_view. The chunk_view divides a range into...

In this milestone 400th episode, Jason addresses the popular question of whether C++ is dying. He presents evidence of C++'s continued relevance by...

This episode continues Jason's mini-series on C++23 ranges by comparing two easily confused views: adjacent_view and slide_view. While both create...

This episode introduces C++23's new zip_view from the ranges library, the first in a mini-series covering new view types. Jason demonstrates how...

This episode provides a quick introduction to the std::chrono library, highlighting its evolution from C++11 to C++20's calendar and formatting...

This episode explores the various 'emplace' functions available in C++ standard containers and their purpose of constructing objects directly...

In this special milestone episode celebrating 100,000 subscribers, Jason provides a transparent look at the financial reality of running a...

This episode explores delegating constructors, a feature introduced in C++11 that allows one constructor to call another constructor of the same...

This episode explores std::unreachable, a new feature in C++23 that explicitly invokes undefined behavior to optimize impossible code paths. Jason...

This episode introduces Bloaty McBloatface, Google's binary size profiler tool. Jason demonstrates how this utility helps developers understand what...

This episode celebrates the long-awaited addition of std::views::enumerate to C++23, a feature that many other programming languages have had for...

This episode explores the seemingly contradictory combination of 'constexpr' and 'mutable' keywords in C++. Jason demonstrates that a lambda marked...

This episode discusses modern C++ alternatives to traditional pointer arithmetic when working with C-style interfaces like main's argc/argv...

This episode introduces cons_expr, Jason's compile-time friendly embedded scripting language for C++ inspired by Lisp/Scheme. Jason explains how this...

In this episode, Jason demonstrates his customized Adafruit MacroPad configured specifically for C++ programming. He shows how he mapped frequently...

This episode explores C++23's new feature allowing attributes to be applied to lambda expressions. Jason demonstrates how attributes like...

This episode provides a concise overview of the most significant C++20 features, including designated initializers that allow specifying struct/class...

This episode explores the unusual concept of using lambdas for everything in C++, presented as a fun thought experiment rather than a best practice....

This episode discusses the importance of learning programming languages beyond C++ to become a better C++ developer, drawing an analogy with athletic...

Jason explores the Static Initialization Order Fiasco in C++ (where interdependent global objects may be initialized in an unpredictable order) and...

Jason explores C++23's new basic_string::resize_and_overwrite function, which improves performance when initializing strings that will be immediately...

In this episode, Jason explores std::ref and std::cref, useful utilities for creating reference wrappers. He demonstrates three key use cases: with...

Jason explores clang-tidy's "bugprone-easily-swappable-parameters" warning, which flags when functions have multiple adjacent parameters of the same...

In this episode, Jason discusses whether it's beneficial to use std::move with std::array. While an array itself cannot be moved (as it's a...

In this episode, Jason shares his perspective on the top features C++ needs in its future evolution. He prioritizes five key improvements: completing...

Jason introduces his updated CMake template for C++ projects in 2023, consolidating his previous templates into a single, streamlined repository...

Jason demonstrates how Interprocedural Optimization (IPO) and Link Time Optimization (LTO) can detect One Definition Rule (ODR) violations that...

This episode explores C++23's new std::out_ptr and std::inout_ptr utilities, designed to simplify interaction between C++ smart pointers and C APIs...

In this episode, Jason discusses design patterns in modern C++, focusing particularly on the Observer pattern (similar to signals and slots in Qt)....

This episode explores CPM (CMake Package Manager), a dependency management solution that integrates seamlessly with CMake. Jason demonstrates his...

This episode outlines best practices for effectively using AI code generation tools like ChatGPT and GitHub Copilot. Jason emphasizes that users must...

This episode challenges the conceptual understanding of C++ constructors by arguing they aren't actually functions that can be called directly, but...

This episode explores llvm-mos, a modern compiler toolchain that enables C++23 programming for 6502-based 8-bit computers like the Commodore 64,...

This episode explores template-template parameters in C++, which allow functions or classes to accept template types (like std::vector) rather than...

This episode explores std::valarray, a largely forgotten part of the C++ Standard Library that was introduced in C++98 and has received minimal...

This episode compares the performance of C++, regular Python, PyPy JIT, and Codon (a Python-to-native compiler) implementations of Conway's Game of...

This episode explores the surprising complexity of the modulo operation in various programming languages. Jason demonstrates that different languages...

This episode explores implementing a Python-inspired function memoization cache in C++. Jason builds a generic caching wrapper that can store the...

This episode provides a comprehensive guide to C++ unions, explaining their core properties and evolution since C++98. Jason demonstrates how unions...

Jason compares performance between C++, standard Python (CPython), JIT-compiled Python (PyPy), and Python with embedded C++ (via cppyy) using...

Jason explores ways to create a more modern, type-safe version of the main() function in C++. He demonstrates a pattern that forward-declares a...

Jason explores cppyy, a Python library that enables C++ code to be compiled and executed within Python scripts. He demonstrates how cppyy dynamically...

Jason explores the internal implementation of std::array by creating a simplified version from scratch. He reveals that std::array is essentially a...

Jason explores two new preprocessor directives coming in C23 and C++23. First, he demonstrates the #embed directive, developed by JeanHeyd Meneide...

Jason explores the difference between using 'typename' and 'class' keywords in C++ templates. He explains that for most template parameters, these...

Jason explores Python-enabled graphing calculators as accessible tools for learning programming without needing internet connectivity or complex...

Jason presents a simplified three-step approach to safer C++ development. He starts with a prerequisite (step 0) of having a continuous...

Jason explores the capabilities of ChatGPT as a tool for programming in C++, demonstrating its ability to convert code between different language...

Jason argues that implicit conversions are a dangerous C++ feature that should be removed from the language. Through multiple code examples, he...

In this episode, Jason advocates for the essential practice of fuzz testing in C++ development. He demonstrates how fuzz testing — a technique that...

This episode provides a structured approach to deepen C++ knowledge through hands-on experimentation. Jason outlines a five-step plan: 1) Create an...

This episode outlines a comprehensive approach to modern C++ development, emphasizing that we're in a 'golden age' of C++ tooling. Jason covers...

This episode introduces C++23's std::move_only_function, a new feature designed for working with non-copyable callables. Jason demonstrates how...

This comprehensive episode serves as a rapid-fire introduction to modern C++ by demonstrating how understanding lambdas provides insight into nearly...

This episode examines a serious security vulnerability in the PlayStation 5 that led to a jailbreak exploit. Jason explains how the vulnerability...

This episode explores C++23's bind_back function, a utility that binds arguments to the end of a callable object's parameter list. Jason demonstrates...

This episode addresses the absence of networking in the C++20 and C++23 standards, providing a comprehensive overview of available third-party...

This episode explains decltype(auto), a powerful C++11 feature that deduces the exact type of an expression, including reference and const...

This episode explores different approaches to type erasure in C++, showcasing techniques to hide exact types at runtime. Jason demonstrates three...

This episode provides a quick introduction to C++20's Ranges library. Jason presents four key benefits: simplified algorithm calls without manually...

This episode compares the C++20 standard format library with the standalone {fmt} library it's based on. Jason highlights key differences including...

This episode demonstrates how C++20 Ranges provide an elegant solution to the long-standing challenge of string splitting in C++. Jason shows how...

This episode provides a crucial follow-up to Episode 312, clarifying when to use 'static constexpr' versus 'inline constexpr'. Jason demonstrates...

This episode demonstrates how to analyze and optimize C++ build times using Clang's time-trace feature. Jason examines his ChaiScript project,...

This episode explores key features coming in C23 that impact C++ programmers, particularly focusing on interoperability between the languages. Jason...

This episode explores the new std::stacktrace library coming in C++23, which provides runtime access to the current call stack. Jason demonstrates...

In this channel news update, Jason discusses his various ongoing projects and ways viewers can get involved. He highlights his books (including his...

This episode explores different approaches to storing lambdas in containers in C++. Jason demonstrates three methods: using std::function (with...

This episode demonstrates how to create a simplified implementation of std::function in C++20. Jason builds a type-erased function wrapper...

This episode clarifies the key differences between lambdas, std::function, and function pointers in C++. Jason demonstrates that lambdas are language...

In this episode, Jason introduces a new educational project he's been developing: a game designed to teach C++ programming. The project combines...

This episode explores the 'extern template' feature added in C++11 and how it can significantly reduce compilation times. Jason demonstrates how...

This episode examines Link Time Optimization (LTO), also known as Inter-Procedural Optimization (IPO), and its significant performance benefits....

This episode demonstrates how C++23's 'deducing this' feature enables a clean implementation of recursive lambdas, a capability that was awkward to...

This episode explores C++23's new multidimensional subscript operator support, which allows for a more intuitive syntax when working with matrix-like...

This episode explores C++23's 'deducing this' feature, which solves the common problem of duplicating code when implementing both const and non-const...

This episode explores why std::vector behaves differently from other vector specializations in C++. Jason explains that vector uses a...

This episode explores C++20's standardized feature test macros, which provide a compile-time way to check if specific C++ features are supported by...

This episode introduces a seemingly small but important new feature in C++23: the auto{} and auto() syntax for creating explicit copies of objects....

This episode explores four scenarios where using 'const' can have unexpected negative performance implications in C++. Jason demonstrates how 'const'...

Jason reviews the results of his first C++ Best Practices Game Jam, where participants created console games following the theme "round" using the...

Jason explores how to use inline namespaces to handle ABI compatibility in C++ libraries. Introduced in C++11, inline namespaces allow library...

Jason introduces his json2cpp tool that converts JSON data into compiled C++ code with zero runtime overhead. Unlike constexpr JSON parsing, this...

Jason shares how his C++ meetup group tackled the challenge of creating a currying function in C++. Starting with a basic implementation that could...

Jason examines how member functions are internally implemented by C++ compilers. Using assembly code analysis, he reveals that member functions...

This episode provides a fundamental introduction to const member functions in C++. Jason explains how const member functions indicate that a method...

Jason investigates the performance differences between regular constexpr and static constexpr variables through detailed benchmarks across GCC,...

Jason comprehensively explores all possible techniques to force C++ compilers to perform calculations at compile time. He explains that simply...

Jason explores a five-year journey to solve a challenging constexpr problem: how to efficiently transfer compile-time string data to runtime without...

This episode clarifies common misconceptions about constexpr variables in C++. Jason demonstrates that constexpr variables alone don't guarantee...

This episode examines the differences between pre-increment (++i) and post-increment (i++) operators in C++. Jason explains that these operators have...

This episode highlights a significant but often overlooked issue with small integer operations in C++. Jason demonstrates how operations with...

In this episode, Jason explores whether code comments should be considered a 'code smell' - a characteristic that might indicate deeper problems in...

This episode builds on the previous discussion of C++23's 'if consteval' feature (episode 304), correcting and expanding on its primary motivation....

In this episode, Jason discusses his initiative to make C++ more fun and accessible, particularly for beginners and non-programmers. He introduces...

This episode explores the concept of local functions in C++ and explains why true local function definitions are not possible in the language. Jason...

This episode makes a compelling case against the use of 'using namespace' directives in C++ code. Jason explains how these directives can create...

This episode explores C++23's new 'if consteval' feature, comparing it to C++17's 'if constexpr' and C++20's 'std::is_constant_evaluated()'. Jason...

This episode presents a programming exercise that challenges viewers to replace traditional functions with lambdas in their C++ code. Jason explains...

This episode explores std::complex, a template class in the C++ Standard Library for representing complex numbers with real and imaginary parts....

Jason presents the third in his series of C++ homework assignments, challenging viewers to maximize the use of constexpr in their code. Using the...

Jason presents the second in his series of C++ homework assignments, challenging viewers to take an existing C++ project and make everything const...

Jason explores the libabigail toolset, focusing on the abidiff utility which helps detect Application Binary Interface (ABI) changes between...

Jason challenges viewers with a coding exercise: take an existing C++ program and convert as many variable, parameter, and return types as possible...

Jason addresses common criticisms of the `auto` keyword in C++ by demonstrating how C++20 concepts can be used to constrain automatic type deduction....

Jason responds to feedback on his implementation of the xoroshiro128 random number generator from Episode 285, focusing on API design considerations...

Jason explores programming for the Commander X16, a new retro computer project led by the 8-Bit Guy (David Murray). Using his C++ for 6502 toolchain,...

In this episode, Jason provides an update on his C++20 RPG game project, which is now running on a Commodore 64 emulator using 6502 assembly. He...

This episode examines the safety aspects of using goto statements in C++. Jason explains that while goto is generally discouraged, the C++ compiler...

This episode explains how to safely treat non-const objects as const when you need to call const-qualified member functions. Jason addresses feedback...

This episode explores two lesser-known C++14 features that enhance code readability. Jason demonstrates binary literals, which allow directly...

This episode examines a lesser-known C++ feature: the ability to return a void expression from a void function. Jason explores how this capability,...

This episode demonstrates the performance benefits of using auto over explicit type declarations in C++. Jason explains that auto prevents unintended...

This episode clarifies common misconceptions about C++'s auto keyword, explaining that it follows the same type deduction rules as template...

This episode explores the fascinating history of dual-monitor support in DOS-era computing, specifically how games like Command and Conquer could...

This episode explores techniques for creating stably random content in games, inspired by classics like Elite that used procedural generation to...

This episode addresses the problems that arise when comparing signed and unsigned integers in C++. Jason demonstrates how comparing a negative value...

This episode explains why using const_cast in C++ is dangerous and should be avoided. Jason demonstrates that modifying const objects leads to...

This episode examines a performance optimization opportunity found in Dave Plummer's 'Prime Number Sieve' comparison code. Jason identifies that a...

This episode demonstrates the remarkable performance improvements possible with C++17's parallel algorithms library. Jason showcases a Mandelbrot set...

In this episode, Jason explores Amazon's newly open-sourced O3DE (Open 3D Engine) codebase, examining it from a C++ perspective. Using tools like...

This episode continues the performance analysis of a quicksort implementation, focusing on a subtle but significant optimization in iterator...

This episode explores the differences between emplace_back() and push_back() in C++ standard containers, examining both their semantic differences...

This episode examines how using the wrong integer type can significantly impact performance. Jason demonstrates a quick sort implementation that was...

Jason Turner explores C++20's new conditionally explicit specifier, which allows constructors and conversion operators to be explicitly marked based...

Following up on his previous episode comparing std::pair to a custom implementation, Jason Turner outlines three steps for effectively trusting the...

Jason Turner investigates why a simple custom pair implementation outperforms std::pair in benchmarks by up to 310x in some compiler configurations....

Jason Turner explores a new C++23 feature that simplifies lambda syntax by making parameter lists optional when using lambda specifiers like...

Jason Turner revisits and updates his Commodore 64 C++ project, now renamed "6502 for C++". He compares different 'Hello World' implementations in...

Jason Turner compares two methods of emptying a std::string: using the clear() member function versus assigning an empty string literal (string =...

This episode discusses the importance of breaking ABI (Application Binary Interface) stability to allow C++ to evolve and improve. Jason explains...

Jason explores the newly available constexpr support for std::vector and std::string in C++20, showing how to use these containers in constexpr...

Jason Turner presents his top 10 essential C++ resources, compiled with input from his Twitter followers. The list includes online communities like...

This episode covers the C++20 additions of starts_with and ends_with methods to std::string and std::string_view. Jason explains how these handy...

This episode explores C++20's new std::shift_left and std::shift_right algorithms, which provide a standardized way to shift elements within...

This episode explores C++20's std::bit_cast, a new function that provides a safe and well-defined way to reinterpret the bit pattern of one type as...

This episode explores covariant return types in C++, which allow a derived class to override a virtual method with a more specific return type. Jason...

This episode explains virtual inheritance in C++, a feature that many programmers misunderstand. Jason demonstrates how virtual inheritance solves...

This episode explores the confusing behavior and inconsistent semantics of std::string's eleven different constructors. Jason demonstrates how two...

This episode introduces C++20's consteval keyword, which enforces that a function must be evaluated at compile time. Jason explains that consteval is...

This episode explains C++'s "most vexing parse" problem, a parsing ambiguity that occurs when trying to default-construct an object with empty...

This episode explores the Curiously Recurring Template Pattern (CRTP), a C++ design pattern where a class inherits from a template instantiated with...

This episode explores C++20's std::source_location, a powerful new feature for compile-time source code introspection. Jason demonstrates how this...

This episode demonstrates why uninitialized variables in C++ lead to undefined behavior and unpredictable program outcomes. Jason shows how different...

Jason explores C++11's little-known garbage collection specification, a feature that was standardized but never implemented by any compiler. The...

Jason surveys C++11, C++14, and C++17 features that still lack cross-platform compiler support as of January 2021. The most notable omission is...

Jason discusses the first core language feature to be accepted into C++23: literal suffixes for signed and unsigned size_t types. Though not yet...

Jason announces that C++20 has been officially released as ISO/IEC 14882:2020 and explains the various ways to access the C++ standard documentation....

Jason demonstrates how Polymorphic Memory Resources (PMR) can dramatically improve JSON parsing performance through practical benchmarks. Using...

Jason explores C++20's Class Non-Type Template Parameters (CNTTP), showing how they enable the use of compile-time known values in contexts where...

Jason explores the practical benefits of custom memory allocation strategies in C++, particularly using PMR (Polymorphic Memory Resources). He...

Jason explores three categories of types in C++ that cannot be directly named by the programmer: lambda types (which have compiler-generated unique...

Jason provides a comprehensive overview of C++17's Polymorphic Memory Resources (PMR), explaining the different standard memory resources including...

Jason explores the various compiler optimization flags available in GCC and Clang, explaining the differences between -O0 (no optimization), -O1/2/3...

In this short and entertaining episode, Jason deconstructs the cryptic C++ expression (+[](){})(), which he spotted on a t-shirt at the Code Dive...

In this follow-up to previous PMR episodes, Jason addresses mistakes in his earlier allocator discussions. He clarifies terminology (memory resource...

In this special update episode, Jason Turner shares news about his YouTube channel and related projects. He discusses switching to DaVinci Resolve...

In this foundational computer science episode, Jason explores the two's complement representation used for signed integers in computers, now...

In this episode, Jason Turner introduces the 'Design by Introspection' pattern, which combines C++20's concepts with C++17's if constexpr to create...

In this episode, Jason Turner explores an unconventional debugging technique: using the `explicit` keyword on copy constructors to identify...

In this episode, Jason Turner explores the [[nodiscard]] attribute introduced in C++17 and enhanced in C++20. He demonstrates how it can help prevent...

This episode explores the difference between std::mem_fun (deprecated in C++11, removed in C++17) and its replacement std::mem_fn (introduced in...

In this episode, Jason explores the seemingly contradictory concept of 'const mutable lambdas' in C++. He demonstrates why this combination is...

This episode shares Jason's personal journey and methodology for learning C++ through experimentation and hands-on investigation. He demonstrates how...

This episode explores how to create custom allocator-aware types in C++ that can properly work with the Polymorphic Memory Resource (PMR) library....

This episode explores C++17's Polymorphic Memory Resources (PMR) in-depth, following up on a previous introduction. Jason demonstrates how PMR can...

This episode compares the square bracket operator (map[key]) with the at() method (map.at(key)) for accessing std::map elements. Jason examines the...

This episode compares the performance of std::map with a simple hand-crafted constexpr map implementation. Jason demonstrates how using a...

This episode explores the C++20 'using enum' feature, which allows enum class values to be used without full qualification in local scopes. Jason...

This episode explores C++20's ability to define multiple conditional destructors using concepts. Using a template-like 'optional' class, Jason...

This episode demonstrates how to build a high-performance domain-specific language (DSL) for matching bit patterns in C++. Jason implements a...

This episode explores why C++20 has deprecated the use of the comma operator in array subscripts. Jason demonstrates how the comma operator can be...

This episode introduces the new mathematical constants provided in C++20 through the header. Jason demonstrates the new std::numbers...

This episode continues the RPG game engine series, focusing on building a testable event system that can replay game events deterministically. Jason...

This episode explores the special behavior of the arrow operator (->) in C++, explaining how it uniquely handles operator overloading. Jason...

Jason provides a comprehensive introduction to operator overloading in C++, demonstrating three different approaches for binary operators: free...

In this fifth part of the RPG in C++20 series, Jason continues developing his game engine by improving input handling. He refines the joystick input...

Jason highlights the often overlooked std::nextafter function from the C++ standard library, which returns the next representable floating-point...

Jason explores C++17's Polymorphic Memory Resources (PMR) to significantly improve container performance. He demonstrates how to use...

Jason explores tools for automatically generating a .clang-format configuration file for his C++ Doom project. He demonstrates using two tools -...

Jason examines C++20's new [[likely]] and [[unlikely]] attributes, which provide branch prediction hints to the compiler. These attributes allow...

In this fourth part of the RPG in C++20 series, Jason focuses on handling user input through joysticks/gamepads using the SFML library. He explores...

This episode explores C++20's std::to_array utility function, which allows converting C-style arrays to std::array. Jason demonstrates how this...

Jason compares performance metrics between the original Crispy Doom (C code) and his C++ port. Surprisingly, the C++ version produces a slightly...

This episode introduces two new C++20 standard library functions: std::lerp (linear interpolation) and std::midpoint. Jason demonstrates why these...

In this episode of the C++20 RPG series, Jason implements command-line parameter handling using the docopt library. He upgrades the project to C++20,...

Jason introduces CTRE (Compile Time Regular Expressions), a library by Hana Dusíková that processes regular expressions at compile time rather than...

In this episode of his C++20 RPG series, Jason demonstrates how to establish a robust development environment that catches errors early. He enables...

Jason explores the new bit manipulation utilities in C++20's header, highlighting several useful functions for low-level bit operations. The...

Jason sets up the initial project structure for his C++20 RPG game series using the C++ Starter Project template as a foundation. He walks through...

In this introductory episode, Jason Turner outlines his upcoming series about building a 2D top-down RPG game using C++20. He discusses the project's...

In this extensive episode, Jason tours his `cpp_starter_project` GitHub repository, which serves as a comprehensive modern CMake template for C++...

This episode introduces C++20's new thread management features: std::jthread and std::stop_token. Jason demonstrates how std::jthread enhances the...

In this episode, Jason explores a potential pitfall with Class Template Argument Deduction (CTAD) in C++17, specifically related to implicit...

This final episode of Jason's five-part Christmas class series provides answers to the questions posed in Chapter 5. Jason explains that lambdas...

This episode concludes Jason's five-part Christmas class series on lambdas with 'Lambdas To The Limits', focusing on advanced and sometimes unusual...

This episode is the fourth chapter in Jason's special five-part Christmas class series on lambdas. Jason first explains the solution to Chapter 3's...

This episode is the third chapter in Jason's five-part Christmas class series on lambdas, focusing on practical applications. First, Jason reviews...

This episode serves as the second chapter in Jason's special five-part series on lambdas, focusing on practical applications and advanced techniques....

In this landmark 200th episode, Jason kicks off a special five-part educational series on C++ lambdas. This first chapter provides an introduction to...

This episode explores how to apply the [[nodiscard]] attribute to constructors in C++20, which warns when constructor results are ignored. Jason...

This episode examines how certain C++ best practices have remained unchanged for 25 years by testing them in Borland C++ for OS/2 from 1994. Jason...

This episode explores the curious `requires requires` syntax in C++20 concepts. Jason explains that this pattern appears when making ad-hoc...

This episode explains C++20's new constinit keyword, which forces variables to be initialized at compile time without making them constant. Jason...

This episode explores the evolution from SFINAE (Substitution Failure Is Not An Error) to C++20's Concepts feature. Jason demonstrates how...

This episode introduces the new contains() member function coming in C++20 for associative containers (set, multiset, map, multimap, unordered_set,...

In this episode, Jason explains why using double underscores or leading underscores in C++ identifiers invokes undefined behavior. The C++ standard...

This episode explores Cevelop, a free and open-source Eclipse-based C++ IDE with powerful refactoring and code analysis capabilities. Jason...

This episode presents a concise overview of the most important features in C++17. Jason highlights guaranteed copy elision, constexpr additions to...

This episode explores C++14's variable templates, a feature that Jason admits he didn't fully appreciate until years after its introduction. He...

This episode introduces C++20's new capability to perform dynamic memory allocation in compile-time constexpr contexts. Jason demonstrates how you...

This episode explores one of C++20's significant improvements: the addition of constexpr qualifiers to most standard algorithms. Jason demonstrates...

This episode explains what callable objects are in C++, defining them as anything that can be treated like a function (called with parentheses)....

This episode focuses on why using reinterpret_cast in C++ is problematic and should be avoided. Jason explains that reinterpret_cast typically...

This episode explains the concept of higher-order functions in C++, defined as functions that either take functions as parameters or return functions...

This episode introduces raw string literals, a feature added in C++11 that simplifies working with complex strings. Jason demonstrates how raw string...

This episode explores the differences between function overloading in C and C++. Jason demonstrates how C++ naturally supports function overloading...

This episode revisits Jason's previous implementation of std::bind_front from C++20 using lambdas, but addresses a critical limitation: the inability...

This episode explores how whitespace is largely insignificant in C++ syntax, a trait inherited from C. Jason demonstrates how the preprocessor...

In this unique episode, Jason demonstrates Power C, a C compiler for the Commodore 64 that was his first introduction to compiled languages. The...

This episode provides a concise overview of the most important features added in C++14, which Jason describes as essentially a 'bug fix' to C++11...

This episode demonstrates how to implement C++20's std::bind_front functionality using modern C++ features. Jason shows a concise implementation...

This episode provides a concise overview of the six most significant features introduced in C++11. Jason explains how auto type deduction,...

This episode introduces C++20's spaceship operator (operator<=>), a powerful new language feature that simplifies comparison operations. Jason...

This episode introduces std::bind_front, a new functional utility coming in C++20. Jason explains how bind_front is a simpler and more focused...

This episode provides a comprehensive overview of the most important features that define C++98/03. Jason identifies four fundamental aspects that...

This episode introduces a significant new feature in Compiler Explorer: execution support in the public web version. Jason announces that users can...

This episode explores a C++20 enhancement to lambda expressions: the ability to expand parameter packs in lambda captures. Jason demonstrates how...

This episode examines C++17's inline variables feature, which simplifies the declaration and definition of static class members. Jason demonstrates...

This episode examines a subtle language change in C++20 that affects aggregate initialization. Jason demonstrates how in C++17, structures with...

This episode explores how to discover and leverage useful compiler warnings in C++. Jason demonstrates using -Wall in Visual Studio and -Weverything...

This episode explains variable shadowing in C++, which occurs when a variable declared in an inner scope has the same name as a variable in an outer...

This episode explores a new feature in C++20 called uniform container erasure that simplifies removing elements from standard containers. Jason...

This episode explores the C++20 feature `std::is_constant_evaluated()` from the header. Jason demonstrates how this function allows...

This episode continues exploring the C++ Box project by implementing a random number generator device. Jason demonstrates how to add a memory-mapped...

This episode explores writing ARM assembly language using the C++ Box project. Jason demonstrates how to use inline assembly within C++ to manipulate...

This episode demonstrates how to implement recursive lambda functions in C++. Jason shows how to create a Fibonacci implementation using lambdas that...

This episode introduces C++ Box, Jason's open-source ARMv4 emulator project written in 100% portable C++. The project provides an integrated...

This episode explains Argument Dependent Lookup (ADL), a C++ language feature that enables calling functions without fully qualifying their namespace...

This episode explores a new C++20 feature allowing virtual functions to be constexpr, which was previously disallowed in C++17 and earlier. Jason...

This episode demonstrates how to instruct compilers to leverage CPU-specific optimizations through compiler flags. Jason shows how to enable advanced...

In this episode, Jason explains why you should never overload the logical operators && and || in C++. Using a simple example with Compiler Explorer,...

In this informational episode, Jason provides an overview of C++ conferences taking place around the world in 2019. He highlights several events...

This episode examines potential dangers when using GNU's function attributes `pure` and `const`. Using Compiler Explorer, Jason demonstrates how...

In this episode, Jason reveals a common but often overlooked C++ optimization: not defining destructors when they aren't needed. Using Compiler...

In this practical episode, Jason demonstrates how to use icecream (a fork of distcc) to create a distributed build environment that utilizes multiple...

In this episode, Jason makes a compelling case that understanding lambdas is a gateway to mastering the most important aspects of C++. He...

This episode demonstrates how C++20's lambda improvements simplify custom comparators in container classes. Jason revisits his previous Episode 94 on...

This episode explores how C++20's lambda enhancements significantly improve resource management patterns. Jason demonstrates a practical application...

In this episode, Jason explores three important lambda enhancements introduced in C++20: default constructible stateless lambdas, assignable...

In this episode, Jason discusses important considerations when using clang-tidy, specifically addressing which checks to avoid. He cautions against...

This episode explores several Python-based tools that can be installed via pip to enhance C++ development workflows. Jason introduces Lizard for...

This episode explores std::to_address, a new utility coming in C++20 that extracts the underlying raw pointer from smart pointers and pointer-like...

This episode demonstrates Visual Studio 2017's built-in static analysis capabilities for automatically detecting when functions can be marked as...

This episode explores GNU's 'pure' and 'const' function attributes which allow developers to communicate that functions have no external side effects...

This episode explores GNU function attributes focusing on the 'always_inline' attribute as an example. Jason demonstrates how to use this...

Jason Turner shares a subtle bug he encountered related to short-circuiting with the logical OR operator. He describes how in his ARM emulator, he...

Jason Turner explores C++20's designated initializers, clarifying the correct syntax (.member = value) and demonstrating that they enforce type...

Jason Turner explains the proper use of C++'s standard output streams: cout, cerr, and clog. He argues against the common practice of using...

Jason Turner explores the complex topic of references to pointers in C++, demonstrating how they differ from regular references and pointers. He...

Jason Turner explores modern C++ capabilities on the MIPS architecture, a RISC processor design from 1985 that remains widely used in networking...

Jason Turner challenges the common misconception that C++ is strictly an object-oriented programming language. He demonstrates that C++ supports...

Jason Turner explores how the 'inline' keyword affects compiler optimization decisions, using Clang's optimization viewer to demonstrate its impact....

Jason Turner explores the {fmt} library and spdlog, demonstrating how they provide a cleaner, more intuitive alternative to C++'s iostream for string...

Jason Turner revisits his approach to creating visitors by inheriting from lambdas, demonstrating significant improvements using C++17 features. He...

In this episode, Jason Turner breaks down what a C++ lambda is by demonstrating its equivalent implementation if written manually. He explains that a...

This episode explores a creative technique using lambdas within C++17 fold expressions. Jason demonstrates how to capture variadic template...

This episode explores how integer literals are handled in ARM assembly compared to x86-64. Jason demonstrates that while Intel processors can...

This episode explores C++20's new for loop init-statements, an extension to range-based for loops that allows variable declarations before the loop...

In this episode, Jason identifies the implicit conversion of C-style arrays to pointers as the most dangerous feature he would remove from C++....

This episode explores C++20's new template syntax for lambdas, which extends C++14's generic lambdas with explicit template parameters. Jason...

This episode introduces designated initializers, a new feature in C++20 that allows explicitly naming structure members during initialization. Jason...

This episode explores how to create lambdas with destruction behavior by capturing objects with custom destructors. Jason demonstrates how lambdas...

This episode examines various approaches to returning values from functions and their performance implications. Jason demonstrates how different...

This episode explores the Advanced Bit Manipulation (ABM) and Bit Manipulation Instruction (BMI) sets available in modern CPUs. Jason demonstrates...

This episode explores the in_place_t constructor parameter used with std::optional, std::variant, and std::any for efficient in-place object...

This episode explores the capabilities and limitations of using std::optional and std::variant in constexpr contexts in C++17. Jason clarifies that...

This episode demonstrates a real-world example of how strict aliasing rules can affect code performance and optimization. Jason shows how the...