C++ Weekly - Ep 54 - Zero Cost Embedded C++ - Part 1

In this episode we get set up with using the latest C++ features to program a chip which has only 2KiB of flash and 128Bytes of RAM available.

C++ Weekly - Ep 53 - Gotos Are Everywhere

In this episode I break down how some C++ features are defined in terms of goto, so we are essentially using goto throughout our code.

C++ Weekly - Ep 52 - C++ To C Compilation

In this episode we play with llvm-cbe, the C back-end for LLVM, which allows us to essentially compile C++ code into C code.

C++ Weekly - Ep 51 - Advanced Stateful Lambdas

In this episode we try to see just how far we can take the idea of a “stateful lambda” by building one that can be manipulated and interacted with from the caller side.

C++ Weekly - Ep 50 - Inheriting Lambdas vs Generic Lambdas

Now that we know why we would inherit lambdas, and merge them into one implementation (to make a visitor, for instance), how and why does this compare to using a generic lambda? What advantage does one have over the other?

C++ Weekly - Ep 49 - Why Inherit From Lambdas?

What is the practical application of for inheriting from lambdas in C++?

C++ Weekly SE - Why 0xFFFFFFFF == 1

Understanding integeral literal sizing and binary arithmetic rules in C and C++.

C++ Weekly - Ep 48 - C++17's Variadic `using`

In this episode I build from episode 40’s discussion on inheriting lambdas and show how several C++17 features (including variadic using declarations) can be combined to create a succinct merging of lambdas.

C++ Weekly - Ep 47 - My Visual C++ Pet Peeve

Last episode I showed you why you should be taking Visual C++ seriously. This episode I show you my personal pet peeve with Visual Studio that has caused many of my portability issues with cross platform development.

C++ Weekly - Ep 46 - Start Using Visual C++

In this episode I demonstrate why you should take Visual C++ seriously and make it a part of your automated build environment.

C++ Weekly - Ep 45 - Compile Time Maze Generator (and Solver)

In this episode I demonstrate how to build a random maze generator (and solver) that can be executed at compile time with constexpr.

C++ Weekly - Ep 44 - constexpr Compile Time Random

In this episode I demonstrate a constexpr enabled random number generator. I then it to generate a different random number sequence each time it is compiled.

C++ Weekly - Ep 43 - Stack Elision?

Is stack elision a thing? What would that imply if it were?

C++ Weekly - Ep 42 - Clang's Heap Elision

In this episode I explore Clang’s ability to elide heap operations.

C++ Weekly - Ep 41 - C++17's constexpr Lambda Support

In this episode I demonstrate how C++17’s support for lambdas in a constexpr context can clean up many constexpr use cases.

C++ Weekly - Ep 40 - Inheriting From Lambdas

In this episode I discuss how (and why) you can inherit from a lambda function along with possible use cases.

C++ Weekly - Ep 39 - C++17's Deduction Guides

C++17’s automatic class template deduction feature brings with it a new sub-feature called “deduction guides” which are used to help the compiler with class template type deduction. I give examples of what they are and how they are used in this episode.

C++ Weekly - Ep 38 - C++17's Class Template Type Deduction

Experimenting with C++17’s class template argument type deduction feature and learning what its limitations are.

C++ Weekly - Ep 37 Stateful Lambdas

Creating stateful lambdas using capture expressions in C++14.

C++ Weekly - Ep 36 Reading Assembly Language - Part 3

Part 3 of our basic introduction to understanding the assembly output from your compiler. In this episode we do some reverse engineering of other non-Intel architectures.

C++ Weekly - Ep 35 Reading Assembly Language - Part 2

Part 2 of our basic introduction to understanding the assembly output from your compiler.

C++ Weekly - Ep 34 Reading Assembly Language - Part 1

Basic introduction to understanding the assembly output from your compiler.

C++ Weekly SE - Visual C++ 1.52 (1993) Review

Review of using Visual C++ 1.52 from 1993. This is the oldest version of Visual C++ available on MSDN.

C++ Weekly - Ep 33 Start Using Default Member Initializers

Why you should use C++11’s default member initializers.

C++ Weekly SE - g++ 2.4.5 (1993) Review

Reviewing g++ 2.4.5 from 1993 on Slackware Linux 1.01.

C++ Weekly - Ep 32 Lambdas For Free

Examining the (free) cost of using lambdas in C++.

C++ Weekly - Ep 31 IncludeOS

I explore what IncludeOS is and how you might use it for OS experimentation.

C++ Weekly - Ep 30 C++17's [[nodiscard]] Attribute

Wrapping up our C++17 attribute coverage with possibly the most interesting yet: [[nodiscard]].

C++ Weekly - Ep 29 C++17's [[maybe_unused]] Attribute

Using C++17’s new [[maybe_unused]] attribute.

Destructuring Standard Containers in C++17

A comment was made on my YouTube channel that destructuring in C++17 would be much more useful if it worked with standard containers. At the moment I responsed that this would be someone impossible to get right without adding too much overhead.

C++ Weekly - Ep 28 C++17's [[fallthrough]] Attribute

Understanding C++17’s new [[fallthrough]] attribute.

C++ Weekly - Ep 27 C++17 Sequence Container Changes

What changes to expect to the sequence containers (for example, std::vector) in the upcoming C++17.

C++ Weekly - Ep 26 Language Features Removed In C++17

C++17 has not only added many new interesting things, it has removed and deprecated a few outdated features as well.

C++ Weekly - Ep 25 C++17's Aggregate Initializations

Continuing coverage of C++17’s new features with new aggregate initialization of base classes.

C++ Weekly - Ep 24 C++17's Structured Bindings

Our continuing series on C++17’s new features with an introduction to C++17’s structured bindings.

C++ Weekly - Ep 23 C++17's __has_include

I continue my series on C++17’s features with the new __has_include functionality.

C++ Weekly - Ep 22 C++17's Nested Namespaces and `std::clamp`

This week I introduce C++17’s nested namespaces and std::clamp library function.

C++ Weekly - Ep 21 C++17's `if` and `switch` Init Statements

This week I introduce C++17’s new support for if and switch init statements.

C++ Weekly - Ep 20 C++17's Fold Expressions - Introduction

This week I introduce C++17’s fold expressions.

C++ Weekly - Ep 19 C++14 For The Commodore 64

Using modern C++ to write extremely efficient high level programs for the Commodore 64.

C++ Weekly Special Edition - Using C++17's constexpr if

In this SE we follow up episode 18’s constexpr if with some concrete examples of where it can be used in existing code.

C++ Weekly - Ep 18 C++17's constexpr if

This week I preview C++17’s upcoming “constexpr if” functionality.

C++ Weekly - Ep 17 C++17's `std::invoke`

This week I preview one of my favorite up coming new features of C++17: std::invoke.

C++ Weekly - Ep 16 Avoiding `std::bind`

Last week we discussed how to use std::bind. this week we discuss why you should never use std::bind

C++ Weekly - Ep 15 Using `std::bind`

Introduction to std::bind from C++11 and how it can be used.

C++ Weekly - Ep 14 Standard Library Gems: `next` and `exchange`

Two somewhat obscure and surprisingly helpful C++ standard library functions.

C++ Weekly - Ep13 Fibonacci: You're Doing It Wrong

Many of the different ways you might implement a Fibonacci sequence in C++ plus one you’ve probably never considered.

C++ Weekly - Ep12 C++17's std::any

In this episode I introduce std::any from the upcoming proposed C++17 standard.

C++ Weekly - Ep11 std::future Part 2

In this episode I correct some of the details of the “std::future Quick Start” episode while expanding on the info provided.

C++ Weekly - Ep10 Variadic Expansion Wrap-Up

In this episode Jason wraps up what we’ve learned so far about variadic templates and shows some additional techniques to consider.

C++ Weekly - Ep9 std::future Quick-Start

In this episode Jason gives a very fast quick-start to what std::future is and how to use std::async to run a function in another thread.

C++ Weekly - Ep8 C++ Name Demangling

In this episode Jason discusses some of what C++ name mangling is, and how to demangle names at runtime.

C++ Weekly - Ep7 Stop Using std::endl

In this episode Jason quickly tries to convince you to stop using std::endl.

C++ Weekly - Ep6 Intro To Variadic Templates

In this episode I give a brief introduction to C++ variadic templates and cover some compile time and runtime performance considerations.

C++ Weekly - Ep5 Intro To ChaiScript

C++ Weekly - Ep4 Variadic Template Refactor

C++ Weekly - Ep3 Intro to clang-tidy

C++ Weekly - Ep2 Cost of Using Statics

C++ Weekly - Ep1 ChaiScript_Parser Initialization Refactor