C++ Nibbles - ahmadsarraj.com

Introduction

You know when you take a small bite of a burger. That’s called a nibble. Just a wee little bite. That is the theme of this series. Bite-sized C++ knowledge. Enjoy!

The series is currently on Nibble #124.

This is the culmination of my entire C++ knowledge. It’s something I would’ve liked younger me to have.

Each Nibble will be:

Less than 4 minutes reading time
Concise (That’s the entire point of a “nibble”).
Contain an actionable takeaway

#000 – How C++ actually runs
#001 – C++ as a high-level language
#002 – The history of C++
#003 – What is C++ used for?
#004 – How do we develop programs? Part 1
#005 – How do we develop programs? Part 2
#006 – Why Debug and Release builds behave differently
#007 – Warnings and error levels. Make the compiler your ally
#008 – Choosing your language standard
#009 – How to use comments
#010 – The modern way of variable initialization
#011 – Using [[maybe_unused]] to suppress compiler warnings
#012 – Prefer ‘\n’ over std::endl
#013 – Avoid default initialization for variables
#014 – Why std::cout << a << b << works
#015 – C++ does not support nested functions
#016 – Using function calls as arguments
#017 – Crash Course on local variables
#018 – Two reasons to use forward declarations
#019 – The std namespace
#020 – Conditional Debugging with Preprocessor Directives
#021 – Thinking in memory. What a variable ACTUALLY is
#022 – Using void as a function parameter
#023 – How big is an int?
#024 – The dangers of using unsigned ints
#025 – Representing numbers in scientific notation. Part 1 – Planning
#026 – Representing numbers in scientific notation. Part 2 – The Program
#027 – Floats or doubles?
#028 – Make all of your variables const (if possible)
#029 – Using literal suffixes
#030 – Printing integers in binary
#031 – std::string_view: A Lightweight String Reference
#032 – Why function arguments may not evaluate left-to-right
#033 – prefix vs postfix increment/decrement operators
#034 – The conditional operator is CHEESE
#035 – How to use std::bitset for EFFORTLESS bit manipulation
#036 – How bit shifting is used in embedded systems
#037 – How to use bit masking to extract meaningful data
#038 – Building a decimal-to-binary converter
#039 – Building a Binary-to-decimal converter
#040 – How the std namespace is organized
#041 – Global mutable variables do not belong in any program
#042 – inline is no longer about performance
#043 – Three ways to share constants across translation units
#044 – When to use static local variables
#045 – The number one mistake beginners make
#046 – How to use inline namespaces to version source code
#047 – Chained, independent, and nested ifs
#048 – Reduce program complexity by using constexpr if statements
#049 – Using [[fallthrough]] to strengthen switch/case blocks
#050 – Three ways to prematurely exit a loop. break vs return vs continue
#051 – Introduction to random number generation in C++
#052 – Crash course on implementing a Mersenne Twister
#053 – Input validation in C++. Why std::cin >> x is fragile – Part 1
#054 – Input validation in C++, Part 2: making std::cin bulletproof – Part 2
#055 – Assertions vs error-handling. When to use each.
#056 – cout, cerr, clog: The three output streams
#057 – Implicit type conversion: where C++ helps, and where it bites
#058 – How numeric promotions allow C++ to be portable and performant
#059 – Type aliases are immensely beneficial
#060 – The Non-Virtual Interface Idiom (NVI)
#061 – Type-safe sum types with std::variant
#062 – Precise return type deduction with decltype(auto)
#063 – Memory-efficient string retrival via c_str()
#064 – Handling optional values safely with std::optional
#065 – Static polymorphism via the Curiously Recurring Template Pattern (CRTP)
#066 – Implementing custom deduction guides for CTAD
#067 – Bounds-checked character access using string::at()
#068 – The Attorney-Client idiom for granular friendship control
#069 – Managing cross-language linkage with extern “C”
#070 – The three-way comparison operator (<=>) for simplified logic
#071 – The role of vptrs in object memory layout
#072 – Using std::any for type-safe heterogeneous containers
#073 – Implementing RAII for graphics: vertex and index buffers
#074 – The mechanics of lambda-to-class conversion by compilers
#075 – Fixed time steps for deterministic physics simulation
#076 – Using std::span for contiguous memory views
#077 – The difference between runtime and compile-time exception checks
#078 – The non-modifying side-effect rule in STL algorithms (LWG 242)
#079 – Memory layout: argument placement on the stack
#080 – Implementing custom unexpected handlers for exceptions
#081 – The typename keyword in nested template types
#082 – Using std::tuple for heterogeneous data grouping
#083 – Vertex and index buffer sharing for mesh instancing
#084 – The transition from std::transform to std::ranges::transform
#085 – Using std::filesystem for cross-platform directory logic
#086 – The difference between InputIt and Forwardit in the STL
#087 – Using std::valarray for high-performance numerics
#088 – Crash course on function overloading
#089 – Stop bad function calls with = delete
#090 – How to implement optional parameters in C++ using default arguments
#091 – How to easily implement function templates
#092 – Making function templates compatible with multiple types
#093 – Using non-type template parameters
#094 – Introduction to value categories
#095 – How C++ lvalue references bind to existing objects
#096 – Why const T& is more flexible than T
#097 – 2 ways to manipulate pointers
#098 – C++ offers a 3rd way to pass in objects
#099 – Why we don’t return non-const static locals by reference