C++ Weekly - Ep 59 - Negative Cost Embedded C++ - Part 2

I continue my series on embedded C++ with an example of how we can merge register accesses and save a few more bytes.



C++ Weekly - Ep 58 - Negative Cost Embedded C++ - Part 1

I continue my series on embedded C++ with an example of how templates and constexpr can provide flexibility while reducing the compile size and increasing performance.



C++ Weekly - Ep 57 - Dissecting An Optimization

In this episode I dissect an optimization that’s unique to Clang.



C++ Weekly - Ep 56 - Zero Cost Embedded C++ - Part 3

We conclude the first part of our series on the MSP430.



C++ Weekly - Ep 55 - Zero Cost Embedded C++ - Part 2

We continue our series on the MSP430 with C++.



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