C++ CMake Tutorial: Build Your First Project
Learn modern CMake for C++ — targets, properties, and dependencies — and configure a small project that compiles cleanly across platforms.
·4 min read · #cpp#cmake#tooling
#cpp
30 posts · page 1 of 1
C++ Coroutines: An Introduction
Understand C++20 coroutines — co_await, co_yield, co_return — and how they enable async and generator-style code without blocking threads.
·4 min read · #cpp#coroutines#async
C++ constexpr and Compile-Time Computing
How constexpr, consteval, and constinit let you move computation from runtime to compile time, with practical patterns and the rules that govern them.
·4 min read · #cpp#constexpr#metaprogramming
C++ Design Patterns Overview
Tour the most useful design patterns in modern C++ — singleton, factory, observer, strategy, RAII — and learn when each one earns its keep.
·4 min read · #cpp#design-patterns#intermediate
C++ Exceptions vs Error Codes
Compare exceptions and error codes in C++ for handling failures — performance, ergonomics, and when each style fits real codebases.
·4 min read · #cpp#error-handling#intermediate
C++ Iterators and Ranges Tutorial
A practical walk through C++ iterator categories, the ranges library, views, and how to compose pipelines that are both safe and zero-overhead.
·4 min read · #cpp#iterators#ranges
C++ Lambda Expressions and Captures
Master C++ lambdas: syntax, capture modes by value and reference, mutable lambdas, generic lambdas, and lifetime pitfalls.
·3 min read · #cpp#lambda#closures
C++ Memory Model and Atomics
Understand the C++ memory model, memory orderings, and how std::atomic enables correct lock-free programming across threads.
·3 min read · #cpp#atomics#concurrency
C++ Move Semantics and Rvalue References
How move semantics work in modern C++: rvalue references, std::move, perfect forwarding, and the rules that decide when your objects are copied versus moved.
·5 min read · #cpp#move-semantics#rvalue
C++ Modules Introduction
Learn C++20 modules: what they replace, how to declare and import them, and how they speed up compilation and clean up the preprocessor.
·3 min read · #cpp#modules#cpp20
C++ Namespaces and Using Directives
Use C++ namespaces to organize code: nested namespaces, anonymous namespaces, using-declarations, and why using namespace std is dangerous in headers.
·3 min read · #cpp#namespaces#using
C++ RAII Resource Management Explained
RAII is the central idea behind safe C++ code. Learn how scope-bound resource ownership eliminates leaks, simplifies error handling, and scales beyond memory.
·4 min read · #cpp#raii#resources
C++ References vs Pointers Explained
A clear comparison of references and pointers in C++, when each is the right tool, and how their semantics interact with const, ownership, and APIs.
·4 min read · #cpp#references#pointers
C++ Smart Pointers: unique, shared, weak
A practical guide to unique_ptr, shared_ptr, and weak_ptr in modern C++: ownership semantics, when to use each, and the pitfalls that lead to leaks and cycles.
·5 min read · #cpp#smart-pointers#memory
C++ STL Containers Cheatsheet
A practical comparison of the C++ standard containers: vector, list, deque, map, unordered_map, set, and friends, with guidance on which to pick when.
·5 min read · #cpp#stl#containers
C++ Templates and Concepts
Templates are how C++ does generic code. Concepts (C++20) make that code readable and debuggable. Here is how both work together in practice.
·5 min read · #cpp#templates#concepts
C++ std::string_view Explained
Learn how std::string_view gives you cheap, non-owning views into strings — when to use it, how it speeds up code, and how to avoid dangling references.
·4 min read · #cpp#strings#performance
C++ Undefined Behavior Pitfalls
A guided tour of the most common undefined behavior traps in C++ and the habits, tools, and language features that help you avoid them in production code.
·4 min read · #cpp#undefined-behavior#safety
C++ Unit Testing with GoogleTest
Set up GoogleTest in a CMake project and write clear unit tests with assertions, fixtures, and parameterized tests for confident C++ code.
·4 min read · #cpp#testing#gtest
C++ Virtual Functions and VTables
Learn how C++ virtual dispatch works under the hood: vtables, vptrs, override, final, and the cost of polymorphism.
·3 min read · #cpp#virtual#vtable
C++ Classes, Constructors, and the Rule of Three
Design C++ classes with constructors, destructors, member initializer lists, and the Rule of Three and Five to manage resources safely.
·5 min read · #cpp#oop#intermediate
C++ Control Flow: if, for, while, switch
Master C++ control flow with if-else, for and range-for loops, while, do-while, switch, and the modern init-statement syntax for conditions.
·5 min read · #cpp#control-flow#beginner
Install C++ and Compile Your First Program
Set up a modern C++ toolchain on macOS, Linux, or Windows, then compile and run your first program with g++ or clang++ from the command line.
·4 min read · #cpp#setup#beginner
C++ Functions, References, and Pass-By-Value
Write C++ functions that pass data correctly: by value, by reference, by const reference, with overloading, default arguments, and clear ownership.
·5 min read · #cpp#functions#beginner
Modern C++ Features You Should Use: auto, range-for, structured bindings
Tour the modern C++ features that pay back every day: auto, range-for, structured bindings, if-init, std::optional, and string_view.
·5 min read · #cpp#modern#intermediate
C++ Pointers and Manual Memory Basics
Learn C++ pointers, the stack vs the heap, new and delete, nullptr, pointer arithmetic, and why modern C++ pushes you toward smart pointers.
·6 min read · #cpp#pointers#intermediate
Modern C++ Smart Pointers: unique_ptr and shared_ptr
Use unique_ptr, shared_ptr, and weak_ptr to model ownership in modern C++ without manual new and delete or memory leaks.
·5 min read · #cpp#memory#intermediate
C++ STL Containers: vector, map, set, unordered_map
Pick the right C++ STL container for the job: vector, deque, list, map, set, unordered_map, and unordered_set with their complexity guarantees.
·5 min read · #cpp#stl#intermediate
C++ Templates: Generics That Compile to Specifics
Learn C++ templates from scratch: function templates, class templates, type deduction, specialization, and how the compiler stamps out concrete code.
·5 min read · #cpp#templates#intermediate
C++ Variables and Fundamental Types
Understand C++ fundamental types, fixed-width integers, floating point, char, bool, const, and how initialization actually works in modern C++.
·5 min read · #cpp#types#beginner