SQLite powers more applications than you might think. It's in every smartphone, most web browsers, and countless desktop applications. Your phone probably has hundreds of SQLite databases on it right now. Despite handling billions of databases worldwide, many developers aren't familiar with all of the cool things that you can do with SQLite.

This tutorial introduces SQLite through practical examples in C/C++, Python, and Java. You can pick and choose the languages that suit your needs. No language wars here. You'll learn how to integrate SQLite into real applications. Whether you're building a desktop app, a web API, or just need local data storage without the drama of a full database server, SQLite has your back.

Code Playbacks

Code playbacks are a unique way to learn about programming. They are guided walkthroughs of code, allowing you to see not just the code itself but also the thought process behind it. This approach helps you understand not only what the code does, but why it was written that way. Here is a short video to show how to move through a code playback:

By registering on Playback Press, you'll gain access to an AI assistant that can answer your questions about the code. This makes learning even more interactive and personalized. Watch this video to see how to work with it:

A Brief Introduction to SQLite

You can find my entire collection of SQLite code playbacks in my free book, "Programming with SQLite".

Here's what you'll learn:

Chapter 1: Database Design and SQL

In this chapter, I cover the basics of relational database design and SQL. I keep it simple and practical. If you'd like more introductory SQL content like this go to my Intro SQL book. If you'd like some SQL problems to work through, check out 30 Worked SQL Examples. If you already dream in SELECT statements, skip ahead to the chapter that best suits your needs.

• 1.1 Database Design and Basic SQL

• 1.2 One-to-Many Relationships and More SQL

• 1.3 Many-to-Many Relationships and Even More SQL

Chapter 2: SQLite in C/C++

In this chapter, I discuss how to use the low level SQLite API from a C or C++ program. You have a lot of power when using the API and I cover ACID transactions. Yes, we're going to talk about pointers and memory management. Even if you're not a C/C++ programmer and haven't touched a pointer since college, I recommend looking at this chapter. Understanding what's happening under the hood will make the other chapters clearer. Plus, you can impress your friends at parties by casually mentioning you know how database transactions really work.

• 2.1 Using the SQLite C/C++ API

• 2.2 An Object Oriented Auction Program

• 2.3 SQLite Transactions

Chapter 3: SQLite in Python

Learn how to use SQLite in any Python program including Flask web apps. No ORMs hiding what's really happening. Just clean, direct database access. I cover how to query and create SQLite databases and then show how to build an API using Flask. By the end, you'll have a working web API that didn't require installing PostgreSQL, configuring connection pools, or sacrificing a weekend to database administration.

• 3.1 Using a SQLite Database in a Python Program

• 3.2 Creating SQLite Databases

• 3.3 Using SQLite in a Flask Web Application

• 3.4 Creating a Web API with Flask and SQLite

Chapter 4: SQLite in Java

In this final chapter I give an example in Java using JDBC. Because sometimes you need to write enterprise code, and SQLite works there too. Who says you need Oracle for everything?

• 4.1 Using a SQLite Database in a Java Program

Conclusion

Ready to explore SQLite? Start with the first playback and see how fun database programming can be. Each example builds on the previous one, giving you practical experience with real code. Real code solving real problems.

I'd love to hear your thoughts! Feel free to share your comments, questions, or feedback via email: mark@playbackpress.com. Your input helps me improve and create even better content.

If you've found this tutorial helpful, consider supporting my work through GitHub Sponsors. Your contributions help cover hosting costs and keep Playback Press free for everyone. Thank you for helping me continue creating educational resources for the developer community!

With the release of Swift 6 and its new Embedded Swift compilation mode, developers now have access to a modern, memory-safe, and performant alternative that’s tailored specifically for resource-constrained systems.

While languages like Rust have also emerged to address these issues, Embedded Swift brings the clarity and safety of Swift to microcontroller environments, without giving up on determinism, binary size, or hardware access.

This article introduces Embedded Swift and explores how it compares to traditional C/C++ development. We’ll cover its key features, programming and memory models, how to set up the toolchain for STM32 microcontrollers, and how to link Swift with existing C drivers.

Along the way, we’ll examine performance trade-offs, growing ecosystem support, and the broader industry movement toward memory-safe languages. As I hope you’ll see, Swift is a serious contender in the future of embedded development.

Prerequisites

To get the most out of this article, you should have a basic understanding of programming in Swift and C. Familiarity with embedded hardware platforms and firmware development concepts will also be helpful.

If you're new to embedded systems, consider reviewing this introductory guide to embedded firmware to build foundational knowledge before diving into Embedded Swift.

Scope

This article is intended as a practical introduction to Embedded Swift. It covers:

• An overview of Embedded Swift and its key language features

• Swift’s programming and memory model in an embedded context

• Setting up the Embedded Swift toolchain on macOS for STM32 microcontrollers

• Interoperability with C code and linking to existing low-level drivers

• A look at memory and instruction-level performance

• Future directions and use cases for Embedded Swift

Note that this article does not provide a full tutorial on the Swift language itself. While the primary focus is on STM32, similar principles apply to other supported platforms such as ESP32, Raspberry Pi Pico, and nRF52.

Table of Contents:

• What is Swift? What is Embedded Swift?

• Swift Programming Model

• Swift Memory Management

• Memory and Instruction Cycle Comparison

• How to Setup Embedded Swift

• C-Swift Linkages:

• Future Work

• Conclusion

What is Swift? What is Embedded Swift?

Swift is a modern programming language developed by Apple that combines the performance of compiled languages with the expressiveness and safety of modern language design. While Swift was originally created for iOS and macOS development, it has evolved into a powerful general-purpose language used in server-side development, systems programming, and increasingly, embedded systems.

Embedded Swift is a special compilation mode introduced in Swift 6 that brings the benefits of Swift to resource-constrained platforms like microcontrollers. It lets developers use a safe, high-level language while still producing compact, deterministic, and performant binaries suitable for embedded applications.

Key Features of Swift

Embedded Swift retains many of the powerful language features that make Swift an attractive alternative to C/C++ in embedded development:

Type Safety: Swift uses a strong static type system, which prevents many programming errors at compile time. Unlike C, where type mismatches can result in undefined behavior, Swift ensures all types are used correctly before code even runs.

Strict Type Checking: Swift doesn't allow implicit type conversions that could lose data or cause unexpected behavior. For example:

// This won't compile in Swift
let integer: Int = 42
let decimal: Double = 3.14
let result = integer + decimal  // Error: Cannot convert value of type 'Int' to expected argument type 'Double'

// You must be explicit about conversions
let result = Double(integer) + decimal  // Correct

Non-nullable Types by Default: In C, pointers can be null by default, which introduces risk. In Swift, variables cannot be nil unless explicitly marked as optionals:

var name: String = "John"
name = nil  // Compile error - String cannot be nil

var optionalName: String? = "John"
optionalName = nil  // This is allowed

Memory Safety via ARC (Covered in detail later):

Swift manages memory automatically using Automatic Reference Counting (ARC). Unlike manual memory management in C/C++, ARC handles object lifecycles efficiently without unpredictable garbage collection pauses. We'll cover ARC and its impact in embedded contexts in a dedicated section later.

Modern Syntax:
Swift's syntax is clean, consistent, and designed for readability. It supports modern paradigms including:

• Functional programming (map, filter, reduce)

• Generics (type-safe abstractions)

• Protocol-Oriented Programming (discussed in the next section)

These features allow you to write more expressive and maintainable code compared to procedural C or inheritance-heavy C++.

Performance:
Swift is designed to perform on par with C++ in many scenarios. Optimizations such as inlining, dead code elimination, and static dispatch help ensure that high-level abstractions don’t compromise performance. In embedded mode, Swift disables features like runtime reflection and dynamic dispatch to further reduce overhead.

To fully leverage Swift for embedded development, it's important to understand its programming model. Unlike C’s procedural approach or C++’s class-heavy design, Swift promotes protocol-oriented programming and composition, which offers both flexibility and safety in embedded system design.

Swift Programming Model

Swift embraces a multi-paradigm programming model that blends object-oriented, functional, and protocol-oriented programming, all underpinned by strong type safety and memory safety.

For embedded developers coming from C or C++, this model may feel different at first. But it provides a more modular and testable way to build complex systems, something especially valuable in embedded applications where hardware abstraction and strict reliability are critical.

Protocol-Oriented Programming (POP)

Swift emphasizes protocols over inheritance, encouraging developers to define behaviors through protocols and implement them using value types like struct and enum, rather than relying heavily on classes.

This philosophy favors composition over inheritance, allowing you to build complex functionality by combining smaller, well-defined components.

Key Concepts:

• protocol defines required behavior.

• Protocol extensions provide default behavior.

• Prefer value semantics using struct.

Example:

protocol Speakable {
    func speak()
}

extension Speakable {
    func speak() {
        print("Default sound")
    }
}

struct Dog: Speakable {
    func speak() {
        print("Woof!")
    }
}

Embedded Swift uses protocols with static dispatch. With static dispatch, the compiler knows the exact memory address of the function to call and can generate a direct jump instruction. There's no runtime lookup, no indirection, and no uncertainty.

Why POP Matters for Embedded Systems

First, you get flexible hardware extraction. Protocols make it easy to define interfaces for hardware components, allowing for mock implementations during testing or platform-specific variations.

Second, you have nice low overhead. Embedded Swift uses static dispatch for protocols, meaning there’s no runtime lookup, and calls are resolved at compile time for maximum performance.

Also, struct and enum types avoid heap allocations, making code more efficient and predictable in low-memory environments.

Now that we’ve explored how Swift’s programming model enables safer and more modular embedded code, let’s turn to another critical piece of the puzzle: memory management. Swift’s use of Automatic Reference Counting (ARC) replaces manual memory handling and offers important benefits, and tradeoffs, for embedded systems.

Swift Memory Management

One of Swift’s most impactful features, especially in the context of embedded systems, is its use of Automatic Reference Counting (ARC) for memory management. Unlike C/C++, where memory must be manually allocated and freed using malloc and free, Swift automates this process while maintaining deterministic performance.

This automation significantly reduces the risk of common memory-related bugs like leaks, dangling pointers, or use-after-free errors, all of which are notorious in low-level C code.

How ARC works

Swift supports ARC not only for the Cocoa Touch API's but for all APIs, providing a streamlined approach to memory management. Unlike garbage collection systems that can cause unpredictable pauses, ARC works deterministically at compile time and runtime to manage memory.

ARC automatically tracks and manages the lifetime of objects in memory based on how many references point to them.

• Reference Counting: Every object has a counter that tracks how many strong references point to it.

• Retain / Release: The compiler inserts retain and release calls automatically during assignment and deinitialization.

• Immediate Deallocation: When the reference count reaches zero, the object is deallocated immediately.

• Deterministic: Unlike garbage collectors, ARC doesn’t introduce unpredictable pauses or runtime scanning.

Swift offers multiple reference types to give you precise control over memory behavior and prevent cycles:

Strong References (default)

• Keeps the referenced object alive.

• Used in most cases.

class MotorController {
    var sensor: SensorData?  // Strong reference

    func updateReading(newData: SensorData) {
        self.sensor = newData  // Previous sensor data automatically deallocated
    }
}

Weak References

• Used to break reference cycles (especially in two-way object relationships).

• Automatically becomes nil when the referenced object is deallocated.

class Device {
    var controller: MotorController?

    deinit {
        print("Device deallocated")
    }
}

class MotorController {
    weak var device: Device?  // ← Weak reference breaks the cycle

    deinit {
        print("MotorController deallocated")
    }
}

func breakCycle() {
    let device = Device()
    let controller = MotorController()

    device.controller = controller
    controller.device = device  // ← This is now a weak reference

    // When this function ends, both objects are properly deallocated
}

breakCycle()
// Output:
// Device deallocated
// MotorController deallocated

Unowned References

• Non-optional version of weak.

• Assumes the object will never be deallocated while still in use.

• More lightweight than weak, but unsafe if misused.

class SensorSystem {
    unowned let controller: MotorController  // unowned reference

    init(controller: MotorController) {
        self.controller = controller
    }
}

class MotorController {
    var sensorSystem: SensorSystem?

    func setupSensors() {
        sensorSystem = SensorSystem(controller: self)
    }

    deinit {
        print("MotorController deallocated")
    }
}

func testUnowned() {
    let controller = MotorController()
    controller.setupSensors()
    // sensorSystem deallocates before controller ends
}

testUnowned()
// Output: MotorController deallocated

ARC Overhead in Embedded Systems

While ARC provides safety benefits, it does introduce some overhead compared to manual memory management:

Memory Overhead:

ARC-managed class instances in Swift typically include an additional 4 or 8 bytes to store reference count metadata, depending on the system architecture, 4 bytes on 32-bit systems and 8 bytes on 64-bit systems. This metadata allows the runtime to track how many active references exist to a given object and deallocate it when no references remain. When developers use weak or unowned references, the memory footprint increases further. These references require additional data structures, such as side tables or tracking mechanisms, to manage object liveness and cleanup. In the case of weak references specifically, Swift maintains zeroing weak reference tables that automatically null out pointers once the referenced object is deallocated, ensuring memory safety.

CPU Overhead:

ARC introduces some runtime overhead due to retain and release operations, which are inserted automatically during reference assignments. These operations involve incrementing or decrementing the reference count and are especially common in code that passes objects between functions or stores them in collections. To ensure thread safety, these updates are typically implemented using atomic operations, which add further instruction cycles. In complex object graphs, ARC may also engage in cycle detection and cleanup through the use of weak references to prevent memory leaks caused by strong reference cycles. While Swift's ARC provides deterministic and efficient memory management, it does so with both memory and CPU costs that developers should consider carefully, especially in performance-critical embedded systems.

Type Safety and Error Prevention

Swift's type system prevents many common errors that plague C/C++ programs:

• Buffer Overflows: Swift arrays are bounds-checked, preventing buffer overflow vulnerabilities that are common in C.

• Null Pointer Dereferences: Swift's optional types make null pointer dereferences impossible at compile time.

• Use After Free: Swift's ownership model prevents use-after-free errors that can cause crashes or security vulnerabilities.

Now that we’ve covered Swift's memory model and ARC behavior, let’s explore how it compares to C in terms of memory usage and instruction cycles, a crucial aspect when evaluating Embedded Swift for real-world deployment.

Memory and Instruction Cycle Comparison

Understanding the performance characteristics of Swift versus C is essential for embedded systems, where every instruction cycle and byte of memory matters. While Swift brings advantages like safety and expressiveness, these benefits come with certain trade-offs in terms of memory usage and runtime behavior that embedded developers must evaluate carefully.

Memory Management:

Swift uses Automatic Reference Counting (ARC) to manage memory. ARC tracks the number of references to each object and deallocates it when no references remain. This eliminates the need for explicit free() calls but introduces overhead.

C, in contrast, uses manual memory management. Developers allocate memory using malloc and release it using free, or rely on the stack for most short-lived data.

The table below provides the memory management comparison between Swift and C:

Swift ensures safety through deterministic cleanup and predictable memory usage. But this comes at the cost of added memory and CPU overhead.

C’s approach offers complete control over memory layout and minimal runtime cost, but increases the risk of memory leaks and fragmentation without disciplined practices.

Instruction Cycle Analysis

The safety features in Swift, such as bounds checking, optional unwrapping, and ARC updates, translate into additional CPU instructions. While this can impact performance, the Swift compiler is aggressive about optimization in release builds. For example, inlining and ARC elision can remove much of the overhead in performance-critical paths.

C has no built-in safety checks, allowing it to generate highly efficient, predictable code. Developers can even use inline assembly for tight control over performance.

The table below provides the instruction cycle comparison between Swift and C:

Although Swift inserts extra instructions for safety, much of this cost can be mitigated through compiler optimization.

C has no such features by default, making it ideal for applications where performance must be tightly controlled and the developer is willing to take full responsibility for safety.

Instruction Count Comparison: Swift vs C Loop Performance

When evaluating Swift and C for embedded use, it's helpful to analyze instruction-level performance on basic operations, such as a loop that processes an array of floating-point numbers. This gives us a concrete sense of the computational cost of each language's safety and abstraction features.

Let’s consider a simple example: summing an array of Float values and returning the average. In Swift, the code uses a high-level for-in loop over an array:

Simple loop performance:

// Swift loop with safety checks
func processData(_ data: [Float]) -> Float {
    var sum: Float = 0.0
    for value in data {  // Iterator with bounds checking
        sum += value     // Safe arithmetic
    }
    return sum / Float(data.count)  // Safe division
}
// Estimated: ~8-10 instructions per iteration

Although elegant and safe, this loop includes several safety mechanisms:

1. Bounds checking on every array access

2. Reference counting if data is passed as a reference type

3. Overflow protection in debug mode

4. Optional handling or runtime checks if data might be empty

These checks introduce runtime overhead, resulting in an estimated 8–10 instructions per iteration on most platforms (depending on optimization level and target architecture). In release builds, Swift aggressively inlines and strips redundant checks, but some level of abstraction cost remains, especially compared to raw memory access in C.

Now, compare that to its equivalent in C:

// C loop without safety checks
float process_data(float* data, int count) {
    float sum = 0.0f;
    for (int i = 0; i < count; i++) {  // Direct pointer arithmetic
        sum += data[i];                // Direct memory access
    }
    return sum / count;  // Direct division (no safety check)
}
// Estimated: ~4-5 instructions per iteration

This version performs direct memory access with pointer arithmetic, no bounds checks, and no type safety. The C code is lower-level, with fewer runtime checks, and compiles down to just 4–5 instructions per iteration, depending on the target CPU and compiler flags. It is lean and fast, ideal for cycles-per-instruction-critical scenarios.

The table below shows the comparison of single loop performance between Swift and C:

Now that we’ve compared Swift and C in terms of memory and cycle costs, let’s move into the practical side: how to set up Embedded Swift on an STM32 platform and get started with real-world development.

How to Setup Embedded Swift

In this section, we'll walk through how to configure and use Embedded Swift for development on STM32 microcontrollers. STM32 is a popular family of ARM Cortex-M–based microcontrollers, commonly used in industrial, consumer, and IoT applications.

Prerequisites

Required Software:

• Swift Development Snapshot (includes the Embedded Swift toolchain)

• Swiftly - Easiest way to manage and install swift toolchains

• Swiftc - Swift Compiler command-line tool

• Python3 - Required to run scripts to convert Mach-O to binary files

• Git (to clone sample repositories) like https://github.com/swiftlang/swift-embedded-examples

• A Unix-like development environment (macOS is currently best supported)

Target Hardware: This guide focuses on STM32 microcontrollers, which are widely used in embedded applications and have excellent community support.

This guide walks you through the full setup process, from installing the required Swift toolchain to flashing the final binary onto your board. We’ll begin by installing the Swift Development Snapshot using Swiftly, a simple command-line utility for managing Swift toolchains. From there, we’ll configure the build system, set up the correct board variant, customize the build script, and compile the Swift and C source code into a binary. Finally, we’ll flash the firmware onto the STM32 using standard tools

Install Swift Development Snapshot

The easiest way to install and manage Embedded Swift toolchains is by using the swiftly tool, which simplifies downloading and using Swift snapshots.

macOS Installation:

The below steps will help install the Swift embedded toolchain:

# Using Swiftly (Recommended)
curl -O https://download.swift.org/swiftly/darwin/swiftly.pkg
installer -pkg swiftly.pkg -target CurrentUserHomeDirectory
~/.swiftly/bin/swiftly init --quiet-shell-followup
source "${SWIFTLY_HOME_DIR:-$HOME/.swiftly}/env.sh"

# Install and use development snapshot
swiftly install main-snapshot
swiftly use main-snapshot

# Verify installation
swift --version

You can clone this Github example repository:

git clone https://github.com/swiftlang/swift-embedded-examples.git 
cd swift-embedded-examples/projects/stm32-blink

The stm32-blink contains:

• Swift code that toggles GPIOs

• A C startup file with vector table

• A build.sh script that uses swiftc, clang, and a custom linker setup

Setup the STM32 Board

Tell the build script which STM32 board is being used:

export STM_BOARD=STM32F746G_DISCOVERY

You can add your own board variant by defining the appropriate memory map and compiler flags in the script.

Modify build.sh (Optional)

Ensure the script correctly locates the following:

• swiftc: should point to the toolchain you installed with Swiftly

• clang: can be macOS’s default Clang

• libBuiltin.a, crt0.s, and macho2bin.py: used to provide minimal runtime support and convert output to flashable binaries

If needed, update these paths:

SWIFT_EXEC=${SWIFT_EXEC:-$(swiftly which swiftc)}
CLANG_EXEC=${CLANG_EXEC:-$(xcrun -f clang)}
PYTHON_EXEC=${PYTHON_EXEC:-$(which python3)}

Ensure the linker flags match your target’s flash and RAM sizes.

Build and Flash the Project:

Run:

./build.sh

This compiles Swift and C code, links them, and produces a blink.bin file.

If successful, you’ll see:

.build/blink.bin  # ready to flash Step 6: Flash the Firmware to STM32

Use ST-Link tools or openocd to flash your board. Example using st-flash:

brew install stlink
st-flash write .build/blink.bin 0x8000000

You should now see an LED blinking.

Here’s a more detailed step by step approach to writing a bare metal code on STM32. For comprehensive installation guides covering other platforms (Raspberry Pi Pico, ESP32, nRF52), detailed IDE configuration, troubleshooting, and advanced examples, you can check out the official documentation:

• Complete Setup Guide: Install Embedded Swift

• Platform Examples: Swift Embedded Examples Repository

• Getting Started Tutorial: Embedded Swift on Microcontrollers

Now that we’ve set up Embedded Swift and explored how to build and run an example project, let’s look at a critical real-world scenario: interfacing Swift with low-level C drivers.

C-Swift Linkages

In many embedded projects, low-level hardware drivers are written in C because of its close-to-metal control and widespread ecosystem support. Embedded Swift supports seamless interoperability with C, which lets you reuse existing C libraries and drivers, write hardware control logic in C, and implement higher-level application logic in Swift.

This hybrid model lets you combine Swift’s safety and productivity with C’s hardware-level control, with no runtime overhead or object translation.

Let’s walk through an example where a low-level sensor driver is implemented in C and the application logic is written in Swift.

C Header File (sensor_driver.h):

This C header file defines the public interface for a low-level sensor driver. It includes standard fixed-width integer types and declares four functions:

• sensor_init(): Initializes the hardware sensor

• sensor_read_temperature() and sensor_read_humidity(): Read raw sensor values

• sensor_delay_ms(): Delays execution for a given number of milliseconds

This interface acts as a bridge between Swift and C. Swift will link to these functions by name, no wrappers or bindings required.

#ifndef SENSOR_DRIVER_H
#define SENSOR_DRIVER_H

#include <stdint.h>

// Low-level sensor driver functions
void sensor_init(void);
uint32_t sensor_read_temperature(void);
uint32_t sensor_read_humidity(void);
void sensor_delay_ms(uint32_t milliseconds);

#endif

C Implementation (sensor_driver.c):

This implementation assumes the sensor is memory-mapped at a fixed address (0x40001000). Each register, temperature, humidity, and control, is accessed by offset from that base address.

The sensor_init() function writes 0x01 to the control register, presumably enabling or starting the sensor hardware.

The sensor_read_temperature() method and sensor_read_humidity() method reads from memory-mapped registers and return the raw ADC values from the sensor.

The sensor_delay_ms() method performs a simple busy-wait loop using nop (no-operation) instructions to approximate a delay. This is suitable for short, coarse-grained delays in bare-metal contexts.

#include "sensor_driver.h"

// Hardware register addresses
#define SENSOR_BASE_ADDR    0x40001000
#define TEMP_REG_OFFSET     0x00
#define HUMIDITY_REG_OFFSET 0x04
#define CONTROL_REG_OFFSET  0x08

void sensor_init(void) {
    // Initialize sensor hardware
    volatile uint32_t* control_reg = (volatile uint32_t*)(SENSOR_BASE_ADDR + CONTROL_REG_OFFSET);
    *control_reg = 0x01; // Enable sensor
}

uint32_t sensor_read_temperature(void) {
    volatile uint32_t* temp_reg = (volatile uint32_t*)(SENSOR_BASE_ADDR + TEMP_REG_OFFSET);
    return *temp_reg;
}

uint32_t sensor_read_humidity(void) {
    volatile uint32_t* humidity_reg = (volatile uint32_t*)(SENSOR_BASE_ADDR + HUMIDITY_REG_OFFSET);
    return *humidity_reg;
}

void sensor_delay_ms(uint32_t milliseconds) {
    // Simple delay implementation
    for (uint32_t i = 0; i < milliseconds * 1000; i++) {
        __asm__("nop");
    }
}

Swift Code Using C Driver:

To use these C functions from Swift, you declare them using @_silgen_name, which tells the Swift compiler to link directly to these symbol names at runtime.

The SensorController class encapsulates sensor-related logic. In its init() method, it calls the sensor_init() function defined in C to initialize the sensor hardware.

The readSensors() method reads the raw values from the C driver, converts them into human-readable units using helper functions, stores them internally, and returns the processed values.

The convertTemperature() and convertHumidity() conversion methods apply a basic linear formula to turn raw ADC values into temperature in Celsius and humidity in percentage, respectively. These formulas would be based on the specific sensor’s datasheet.

The checkThresholds() method applies simple threshold logic, a good example of where Swift’s readability and type safety shine. You could easily expand this logic to include error bounds, state machines, or alerts.

// Import C driver functions

/*
These declarations match the C function signatures exactly. 
They allow Swift to invoke the C functions as if they were native Swift functions 
— with zero overhead.
*/
@_silgen_name("sensor_init")
func sensor_init()

@_silgen_name("sensor_read_temperature")
func sensor_read_temperature() -> UInt32

@_silgen_name("sensor_read_humidity")
func sensor_read_humidity() -> UInt32

@_silgen_name("sensor_delay_ms")
func sensor_delay_ms(_ ms: UInt32)

// Swift sensor controller using C driver
class SensorController {
    private var lastTemperature: Float = 0.0
    private var lastHumidity: Float = 0.0

    init() {
        // Initialize the C driver
        sensor_init()
    }

    func readSensors() -> (temperature: Float, humidity: Float) {
        // Read raw values from C driver
        let rawTemp = sensor_read_temperature()
        let rawHumidity = sensor_read_humidity()

        // Convert raw values to meaningful units in Swift
        let temperature = convertTemperature(rawValue: rawTemp)
        let humidity = convertHumidity(rawValue: rawHumidity)

        // Store for comparison
        lastTemperature = temperature
        lastHumidity = humidity

        return (temperature: temperature, humidity: humidity)
    }

    private func convertTemperature(rawValue: UInt32) -> Float {
        // Convert raw ADC value to Celsius
        return (Float(rawValue) * 3.3 / 4095.0 - 0.5) * 100.0
    }

    private func convertHumidity(rawValue: UInt32) -> Float {
        // Convert raw ADC value to percentage
        return Float(rawValue) * 100.0 / 4095.0
    }

    func checkThresholds() -> Bool {
        // Swift logic for threshold checking
        let tempThreshold: Float = 25.0
        let humidityThreshold: Float = 60.0

        return lastTemperature > tempThreshold || lastHumidity > humidityThreshold
    }
}

// Main application loop
func main() -> Never {
    let sensorController = SensorController()

    while true {
        // Read sensors using Swift controller with C driver
        let readings = sensorController.readSensors()

        // Process data with Swift's type safety and expressiveness
        if sensorController.checkThresholds() {
            print("Warning: Temperature: \(readings.temperature)°C, Humidity: \(readings.humidity)%")
        } else {
            print("Normal: Temperature: \(readings.temperature)°C, Humidity: \(readings.humidity)%")
        }

        // Delay using C driver function
        sensor_delay_ms(1000) // 1 second delay
    }
}

The func main() is the main event loop standard for embedded systems. It creates the sensor controller, reads sensor data in a loop, checks thresholds, and prints results accordingly. The loop includes a delay (via the C driver) to avoid hammering the sensor continuously.

In an actual embedded context, instead of using print(), you might blink an LED, send UART messages, or log data to memory.

With Embedded Swift and C now working together, let’s explore what lies ahead. The next section outlines ongoing improvements, emerging use cases, and research directions that are shaping the future of Embedded Swift.

Future Work

Embedded Swift is still a young but rapidly evolving technology. Its modern language features, type safety, and performance make it an attractive option for embedded development, and ongoing work is expanding its capabilities, reach, and ecosystem.

Ongoing Improvements

Compiler Optimizations: The Swift compiler team is actively improving code generation for embedded targets, including:

• Reducing binary size

• Minimizing ARC overhead

• Improving static dispatch performance

Hardware Support: Embedded Swift can target a wide variety of ARM and RISC-V microcontrollers, which are popular for building industrial applications. Support for additional architectures is being developed.

Tooling Enhancements: Tooling support for Embedded Swift is still evolving, but several community-driven and open-source efforts are making development more accessible:

• Build Systems: The Swift Embedded Working Group provides example projects that adapt Swift Package Manager (SwiftPM) for cross-compilation. Custom linker scripts and build helpers are available for platforms like STM32 and nRF52.

• Debugging Support: Developers can debug Embedded Swift programs using existing tools like GDB or OpenOCD, provided the build includes appropriate debug symbols. While not yet officially streamlined, this approach enables step-through debugging on real hardware.

• IDE Integration: There is no official IDE support yet, but some developers use VSCode with Swift syntax highlighting and external build tasks. These setups are still manual but serve as early prototypes for embedded workflows.

Emerging Use Cases

There are a number of emerging use cases for embedded Swift. For example, Swift’s memory safety, type guarantees, and protocol-oriented design make it ideal for secure and scalable IoT devices, especially where firmware bugs could affect user safety or privacy.

The automotive sector is also exploring Swift for infotainment systems, driver assistance features, and safety-critical logic (where deterministic execution and safety matter).

Swift’s expressive syntax and compile-time safety make it suitable for industrial automation – think real-time control loops, sensor fusion systems, and edge devices in smart manufacturing.

It’s also useful for medical devices, as it aligns well with strict medical regulations around memory safety, type guarantees, and predictable resource usage.

Community and Ecosystem

Open Source Projects

The Swift Embedded working group maintains example repositories showcasing how to use Embedded Swift on microcontrollers such as STM32, nRF52, and ESP32. Early-stage libraries for UART, GPIO, and basic peripherals are emerging, though the ecosystem is still young compared to C or Rust.

Learning Resources

While Embedded Swift is not yet widely taught in formal curricula, community tutorials and exploratory projects (for example, Swift for Arduino) are lowering the barrier for hobbyists and independent learners. As tooling matures, educational adoption is likely to follow.

Industry Interest

Embedded Swift is beginning to draw attention from developers and companies looking for safer, more maintainable alternatives to C. Although large-scale adoption remains limited, use cases like rapid prototyping, IoT development, and internal experimentation are gaining traction.

Conclusion

Embedded Swift represents a major step forward in embedded programming. By combining the power and safety of Swift with the low-level control needed for microcontrollers, it offers an exciting alternative to traditional C and C++ development.

While C will remain essential for hardware-level programming and performance-critical paths, Swift brings compelling advantages to many embedded scenarios:

• Memory safety: Swift eliminates entire categories of bugs such as buffer overflows, use-after-free, and null pointer dereferencing.

• Type safety: Many logic errors are caught at compile time, long before they can cause runtime failures.

• Modern language features: Developers can use functional paradigms, generics, and protocol-oriented design even in embedded code.

• C interoperability: Swift works seamlessly with existing C libraries, allowing gradual adoption without rewriting low-level drivers.

• Developer productivity: Clear syntax, automatic memory management, and strong tooling lead to faster development and easier maintenance.

Government and regulatory bodies are increasingly encouraging or mandating the use of memory-safe programming languages to reduce vulnerabilities in critical software systems. For example:

• In 2022, the U.S. National Security Agency (NSA) recommended moving away from unsafe languages like C/C++ for new software projects, promoting memory-safe alternatives.

• In June 2025, the NSA and CISA released a joint Cybersecurity Information Sheet titled “Memory Safe Languages: Reducing Vulnerabilities in Modern Software Development”, which emphasized that memory safety flaws remain a persistent risk, and organizations should develop strategies to adopt memory-safe programming languages in new systems.

• The U.S. Cybersecurity and Infrastructure Security Agency (CISA) and NIST have echoed similar guidance in the context of national cybersecurity.

While these documents do not mention Swift explicitly, Swift's strong type system, ARC-based memory model, and compile-time safety guarantees align closely with the goals outlined in these recommendations. As such, it offers a practical, developer-friendly path toward safer embedded development.

Swift may not be the right fit for every embedded system. In applications where every byte of memory or instruction cycle is critical, real-time guarantees are hard requirements, or toolchain maturity is essential (for example, RTOS integration, static analyzers), C or Rust may still be preferred.

But in many modern embedded applications, especially those involving rapid prototyping, fast product iteration, safety-critical or maintainable firmware, and interoperability with existing C codebases, Swift offers a highly productive and safe development experience.

Embedded Swift is still maturing, but its momentum is undeniable. With ongoing compiler work, community-driven examples, and growing interest from developers, it’s poised to play a major role in the future of embedded systems.

Whether you're building an IoT device, a piece of industrial equipment, or a proof-of-concept wearable, Swift can help you write safer, more expressive firmware, without giving up performance or control.

Swift can be especially powerful during the prototyping phase, when the primary goal is to validate functionality quickly and safely. And with its increasing support for multiple hardware platforms, it offers a strong foundation for bringing modern software development practices to the embedded world.

In this article, we will learn about infinite loops in C++, their types and causes, and their applications.

Here’s what we’ll cover:

1. What is an Infinite Loop in C++?

2. Types of Infinite Loops in C++

3. Common Causes of Accidental Infinite Loops in C++

4. Applications of Infinite Loops in C++

5. Using Infinite Loops To Take User Input in C++

6. Conclusion

What is an Infinite Loop in C++?

An infinite loop is any loop in which the loop condition is always true, leading to the given block of code being executed an infinite number of times. They can also be called endless or non-terminating loops, which will run until the end of the program’s life.

Infinite loops are generally accidental and occur due to some mistake by the programmer. But they are pretty useful, too, in different kinds of applications, such as creating a program that does not terminate until a specific command is given.

Types of Infinite Loops in C++

There are several ways to create an infinite loop in C++, using different loop constructs such as while, for, and do-while loops. Here, we will explore each method and provide examples.

• Infinite While Loops

• Infinite For Loops

• Infinite do-while Loops

1. Infinite Loop using While Loop

This is the most popular type of while loop due to its simplicity. You just pass the value that will result in true as the condition of the while loop.

Syntax:

while(1)
    or
while(true)

Example Code:

// Example of Infinite loop in C++ using for loop
#include <iostream>
using namespace std;

int main() {
    // Infinite loop using while
    while (true) {
        cout << "This is an infinite loop." << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

………………….

Infinite Loop using For Loop

In a for loop, if we remove the initialization, comparison, and update conditions, then it will result in an infinite loop.

Syntax:

for(;;)

Example Code:

//Example of Infinite loop in C++ using for loop

#include <iostream>
using namespace std;

int main() {
    // Infinite loop using for loop
    for (;;) {
        cout << "This is an infinite loop." << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

Infinite Loop using do-while Loop

Just like the other two loops discussed above, we can also create an infinite loop using a do-while loop. Although this loop is not preferred much due to its longer syntax.

Syntax:

do{
}while(1)

Example Code:

// Infinite loop in C++ using do-while loop

#include <iostream>
using namespace std;

int main() {
   // infinite do-while loop
    do {
        cout << "This is an infinite loop." << endl;
    } while (true);

    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

Common Causes of Accidental Infinite Loops in C++

Infinite loops can be both intentional and accidental. Accidental infinite loops are those which were not intended by the programmer but are caused due to some error in the program.

Following are some of the errors that may cause infinite loops in your programs unintentionally:

1. Missing Update Statements

Infinite loops are caused when you forget to add an update condition inside the loop, which will terminate the loop in the future. The following program illustrates such a scenario:

Example Code:

// Infinite loop caused due to missing update statement

#include <iostream>
using namespace std;

int main() {
    int i = 3;
    while (i < 5) {
        cout << i <<endl;
        // Missing update: i++;
    }
    return 0;
}

Output:

3

3

3

3

3

3

3

……………………

To fix the above code, we can add an update condition inside the loop like this:

// fixed code

#include<iostream>
using namespace std ;

int main() {
int i = 3;
while (i < 5) {
    cout << i << endl;
    i++; // add the condition
}

return 0 ; 

}

Output:

3

4

Incorrect Loop Conditions

The conditions mentioned inside the loop body are crucial to terminate a loop. An incorrect loop condition can result in an infinite loop. The following program illustrates such a scenario:

Example Code:

// Infinite loop caused due to incorrect loop conditions

#include <iostream>
using namespace std;

int main() {
    int i = 2;
    while (i >= 0) {  
        cout << "Hello AnshuAyush " << endl;

    }
    return 0;
}

Output:

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

……………………..

To fix the above code, we can update i inside the loop to eventually make the condition false:

// fixed code 

#include<iostream>
using namespace std ;

int main() {
int i = 2;
while (i >= 0) {  
    cout << "Hello AnshuAyush" << endl;
    i--; // loop will stop
}

return 0 ; 

}

Ouptut:

Hello AnshuAyush

Hello AnshuAyush

Hello AnshuAyush

Logical Errors in the Loop

In many scenarios, infinite loops are caused by small logical errors in the code. The following program illustrates such a scenario:

Example Code:

#include <iostream>
using namespace std;

int main() {
    for (int i = 3; i >2; i += 2) {  
        cout <<"This is an infinite loop" << endl;
    }
    return 0;
}

Output:

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

This is an infinite loop.

……………………….

To fix the above code, we can either use a decreasing condition or use an incrementing loop condition.

Decreasing condition:

for (int i = 3; i > 0; i--) {
    cout <<"This is NOT an infinite loop" << endl;
}

Increasing condition:

for (int i = 3; i < 10; i += 2) {
    cout <<"Loop will end when i reaches 10" << endl;
}

Applications of Infinite Loops in C++

Infinite loops do not only occur by accident, as I mentioned above. You can also create them on purpose for different use cases. The following are some of the common applications where you might use infinite loops intentionally:

• Event loops: Many Graphical User Interfaces (GUIs) use infinite loops to keep the program running and responsive to user actions.

• Server applications: Web servers use infinite loops to continuously listen to client connections or requests.

• Embedded systems: Embedded systems, such as microcontrollers, frequently use infinite loops as their main program loops to continuously respond to external events.

• User inputs: Infinite loops are also used to wait for valid user inputs. The loop keeps running until a valid input is provided by the user. We’ll look at an example of this one.

Using Infinite Loops to Take User Input in C++

Infinite loops are commonly used in scenarios where a program needs to continuously take user input until a specific condition is met, such as exiting the program or getting a valid user input. The following program demonstrates how we can take user input from the user until a specific condition is met:

Example Code:

// C++ Program to take user input from users using infinite loops

#include <iostream>
#include <string>
using namespace std;

int main() {
    string input;

    while (true) {
        cout << "Enter a command (type 'exit' to quit): ";
        getline(cin, input);

        if (input == "exit") {
        // Exit the loop if the user types 'exit'
            break; 
        }

        cout << "You entered: " << input << endl;
        // Process the input
    }
    cout << "Program exited." << endl;
    return 0;
}

Output:

Enter a command (type 'exit' to quit): Anshu

You entered: Anshu

Enter a command (type 'exit' to quit): Ayush

You entered: Ayush

Enter a command (type 'exit' to quit): exit

Program exited.

Conclusion

Infinite loops aren’t always dangerous. They can be very useful when used with proper control, like break statements or condition checks. But if you use them carelessly, they can crash your program.

So just make sure you check your loop conditions and test your code using print statements between the programs to discover any unexpected behavior. In sum, infinite loops can be very powerful when handled carefully but can be very risky if left unchecked.

And if you'd like to support me and my work directly so I can keep creating these tutorials, you can do so here. Thank you!

In this article, we will look at some of the most commonly used built-in functions in C++ so you can start using them in your code.

What we’ll cover:

1. The sqrt() Function

2. The pow() Function

3. The sort() Function

4. The find() Function

5. The binarysearch() Function

6. The max() Function

7. The min() Function

8. The swap() Function

9. The toupper() Function

10. The tolower() Function

The sqrt() Function

You use the sqrt() function to determine the square root of the value of type double. It is defined inside the <cmath> header file.

Syntax:

sqrt (n)

Parameter: This function takes only one parameter of type double which is a number we want to find the square root of.

Return Type: The square root of the value of type double.

Example Code

Let’s look at an example so you can see how this function works:

// C++ program to see the use of sqrt() function
#include <cmath>     
#include <iostream>  

using namespace std;  
int main()
{
    double x = 100;

    double answer;

    // Use the sqrt() function to calculate the square root of the number
    answer = sqrt(x);

    // Print the result 
    cout << answer << endl;

    return 0;
}

Output:

10

The pow() Function

You use the pow() function to find the value of the given number raised to some power. This function is also defined inside the <cmath> header file.

Syntax:

double pow(double x, double y);

Parameters:

• x: The base number.

• y: The exponential power.

Return Type: value of x raised to the power y.

Example Code:

Let’s look at an example to see how this works:

// C++ program to see the use of the pow() function
#include <cmath>
#include <iostream>
using namespace std;

int main()
{
 // Declare an integer variable 'base' 
    int base = 5;

// Declare an integer variable 'exponent' 
    int exponent = 3;

// pow(5, 3) means 5^3 which is 5*5*5 = 125
// Use the pow() function to calculate base raised to the power of exponent
    int answer = pow(base, exponent);

// output the result
    cout << answer << endl;
}

Output:

125

The sort() Function

The sort() function is part of STL's <algorithm> header. It is a function template that you can use to sort the random access containers, such as vectors, arrays, and so on.

Syntax:

sort (arr , arr + n, comparator)

Parameters:

• arr: The pointer or iterator to the first element of the array.

• arr + n: The pointer to the imaginary element next to the last element of the array.

• comparator: The unary predicate function that is used to sort the value in some specific order. The default value of this sorts the array in ascending order.

Return Value: This function does not return any value.

Example Code:

Let’s look at an example:

#include <iostream>     
#include <algorithm>    // Header file that includes the sort() function

using namespace std;    

int main()
{
    // Declare and initialize an integer array with unsorted elements
    int arr[] = { 13, 15, 12, 14, 11, 16, 18, 17 };

    // Calculate the number of elements in the array
    int n = sizeof(arr) / sizeof(arr[0]);

    // Use the built-in sort() function from the algorithm library
    sort(arr, arr + n);

    // Print the sorted array using a loop
    for (int i = 0; i < n; ++i)
        cout << arr[i] << " ";  

    return 0;
}

Output:

11 12 13 14 15 16 17 18

The find() Function

The find() function is also part of the STL <algorithm> library. You use this function to find a value in the given range. You can use it with both sorted and unsorted datasets as it implements a linear search algorithm.

Syntax:

find(startIterator, endIterator, key)

Parameters:

• startIterator: Iterates to the beginning of the range.

• endIterator: Iterates to the end of the range.

• key: The value to be searched.

Return Value: If the element is found, then the iterator is set to the element. Otherwise, it iterates to the end.

Example Code:

Let’s look at an example to better understand how it works:

// C++ program to see the the use of the find() function

#include <algorithm>   // Required for the find() function
#include <iostream>    
#include <vector>      

using namespace std;   

int main()
{
    // Initialize a vector 
    vector<int> dataset{ 12, 28, 16, 7, 33, 43 };

    // Use the find() function to search for the value 7
    auto index = find(dataset.begin(), dataset.end(), 7);

    // Check if the element was found
    if (index != dataset.end()) {
        // If found, print the position (index) by subtracting the starting iterator
        cout << "The element is found at the "
             << index - dataset.begin() << "nd index";
    }
    else {
        // If not found
        cout << "Element not found";
   }
    return 0;
}

Output:

The element is found at the 3rd index

The binary_search() Function

The binary_search() function is also used to find an element in the range – but this function implements binary search instead of linear search as compared to the find() function. It’s also faster than the find() function, but you can only use it on sorted datasets with random access. It’s defined inside the <algorithm> header file.

Syntax:

binary_search (starting_pointer , ending_pointer , target);

Parameters:

• starting_pointer: Pointer to the start of the range.

• ending_pointer: Pointer to the element after the end of the range.

• target: Value to be searched in the dataset.

Return Value:

• Returns true if the target is found.

• Else return false.

Example Code:

Let’s check out an example to see how it works:

// C++ program for the binary_search() function

#include <algorithm>   
#include <iostream>    
#include <vector>      

using namespace std;   

int main()
{
    // Initialize a sorted vector of integers
    vector<int> arr = { 56, 57, 58, 59, 60, 61, 62 };

    // binary_search() works only on sorted containers
    if (binary_search(arr.begin(), arr.end(), 62)) {
        // If found, print that the element is present
        cout << 62 << " is present in the vector.";
    }
    else {
        // If not found, print that the element is not present
        cout << 16 << " is not present in the vector";
    }

    cout << endl;
}

Output:

62 is present in the vector.

The max() Function

You can use the std::max() function to compare two numbers and find the bigger one between them. It’s also defined inside the <algorithm> header file.

Syntax:

max (a , b)

Parameters:

• a: First number

• b: Second number

Return Value:

• This function returns the larger number between the two numbers a and b.

• If the two numbers are equal, it returns the first number.

Example Code:

Here’s an example:

// max() function

#include <algorithm>  
#include <iostream>   
using namespace std;

int main()
{
    // Declare two integer variables
    int a = 8 ;
    int b = 10 ;

    // Use the max() function to find the larger number between a and b
    int maximum = max(a, b);

    // Display the result with a meaningful message
    cout << "The maximum of " << a << " and " << b << " is: " << maximum << endl;

    return 0;
}

Output:

The maximum of 8 and 10 is: 10

The min() Function

You can use the std::min() function to compare two numbers and find the smaller of the two. It’s also defined inside the <algorithm> header file.

Syntax:

min (a , b)

Parameters:

• a: First number

• b: Second number

Return Value:

• This function returns the smaller number between the two numbers a and b.

• If the two numbers are equal, it returns the first number.

Example Code:

Here’s an example:

// use of the min() function

#include <algorithm>  // For the built-in min() function
#include <iostream>   
using namespace std;

int main()
{
    // Declare two integer variables to store user input
    int a = 4 ;
    int b = 8 ;

    // Use the min() function to find the smaller 
    int smallest = min(a, b);

    // Display the result 
    cout << "The smaller number between " << a << " and " << b << " is: " << smallest << endl;

    return 0;
}

Output:

The smaller number between 4 and 8 is: 4

The swap() Function

The std::swap() function lets you swap two values. It’s defined inside <algorithm> header file.

Syntax:

swap(a , b);

Parameters:

• a: First number

• b: Second number

Return Value: This function does not return any value.

Example:

Here’s how it works:

//  use of the swap() function

#include <algorithm>  // For the built-in swap() function
#include <iostream>   
using namespace std;

int main()
{
    int firstNumber = 8 ;
    int secondNumber = 9 ;


    // Use the built-in swap() function to exchange values
    swap(firstNumber, secondNumber);

    // Display values after swapping
    cout << "After the swap:" << endl;
    cout << firstNumber << " " << secondNumber << endl;

    return 0;
}

Output:

After the swap:

9 8

The tolower() Function

You can use the tolower() function to convert a given alphabet character to lowercase. It’s defined inside the <cctype> header.

Syntax:

tolower (c);

Parameter(s):

• c: The character to be converted.

Return Value:

• Lowercase of the character c.

• Returns c if c is not a letter.

Example Code:

Here’s how it works:

// C++ program

// use of tolower() function

#include <cctype>     
#include <iostream>   
using namespace std;

int main()
{
    // Declare and initialize a string with uppercase characters
    string str = "FRECODECAMP";

    for (auto& a : str) {
        a = tolower(a);
    }

    // Print the modified string 
    cout << str;

    return 0;
}

Output:

freecodecamp

The toupper() Function

You can use the toupper() function to convert the given alphabet character to uppercase. It’s defined inside the <cctype> header.

Syntax:

toupper (c);

Parameters:

• c: The character to be converted.

Return Value

• Uppercase of the character c.

• Returns c if c is not a letter.

Example Code:

Here’s how it works:

// use of toupper() function

#include <cctype>     
#include <iostream>   
using namespace std;

int main()
{
    // Declare and initialize a string 
    string str = "freecodecamp";

    for (auto& a : str) {
        a = toupper(a);
    }

    // Output the converted uppercase string
    cout << str;

    return 0;
}

Output:

FREECODECAMP

Conclusion

Inbuilt functions are helpful tools in competitive programming and in common programming tasks. These help in improving code readability and enhance the efficiency of code. In the above article, we discussed some very useful common inbuilt functions. Some common inbuilt functions are max(), min(), sort(), and sqrt(), etc. By using these inbuilt libraries, we can reduce boilerplate code and speed up the process of software development. These help in writing more concise, reliable, and maintainable C++ programs.

And if you'd like to support me and my work directly so I can keep creating these tutorials, you can do so here. Thank you!

We just published a comprehensive tutorial on the freeCodeCamp.org YouTube channel that will help you improve you C++ skills by building an audio plugin. This course about writing code and gaining the skills to bring your sonic ideas to life.

Chuck from Matkat music created this course. He is a 3x Grammy nominated arranger, sax player, producer, and coder.

Here are just a few reasons why you should consider learning C++ audio plugin development with JUCE:

• Unlock Creative Potential: Build custom effects and instruments that are perfectly tailored to your creative needs, going beyond the limitations of off-the-shelf plugins.

• Deepen Your Programming Skills: C++ is a powerful language widely used in the audio industry. Learning JUCE will enhance your C++ knowledge and introduce you to the intricacies of real-time audio programming.

• Tap into a Robust Framework: JUCE is a comprehensive open-source framework specifically designed for audio applications. It simplifies complex tasks and provides a solid foundation for building professional-grade plugins that run on multiple platforms.

• Understand Audio Processing: Gain a deep understanding of digital signal processing (DSP) concepts and how to implement them to create various audio effects like phaser, chorus, overdrive, and filters.

• Build Professional Tools: Develop the skills to create plugins with responsive graphical interfaces (GUIs), parameter controls, metering, and state management.

Ready to take the plunge into the world of audio plugin development and create your own signature sound? Check out the full tutorial on the freeCodeCamp.org YouTube channel (8-hour watch).

We just published a course on the freeCodeCamp.org YouTube channel that will teach you all about setting up a professional-grade C++ development environment using tools like CMake, vcpkg, Docker, and GitHub Copilot. This comprehensive course walks you through setting up your environment across Windows, Linux, and macOS, ensuring that you're well-equipped no matter what platform you're on. You’ll learn how to configure CMake and vcpkg, which simplifies the process of handling C++ libraries and dependencies. The course also covers Docker-based setups, making it easy to create portable, reproducible development environments. Daniel Gakwaya developed this course.

Let’s break down these essential tools:

CMake is a widely used build system generator that helps manage the compilation process of C++ projects in a platform-independent manner. It allows you to write simple configuration files (CMakeLists.txt) to define how your code should be compiled, what dependencies to include, and how to organize your project. Instead of writing custom build scripts for each operating system, CMake lets you write one unified configuration and generate platform-specific build files automatically. This is a game-changer for cross-platform development and is favored by many open-source and enterprise-level projects.

vcpkg is a C++ library manager developed by Microsoft that integrates seamlessly with CMake. It automates the process of downloading, building, and installing third-party libraries, saving you from the tedious and error-prone task of configuring each library manually. With a single command, you can install libraries like Boost, OpenCV, or fmt and have them ready to use in your project. vcpkg ensures consistency across systems and makes dependency management much more maintainable and scalable.

Docker is a tool designed to create and manage lightweight containers that package your application and its environment. For C++ developers, Docker is especially useful for setting up reproducible development and build environments. You can configure a Docker container with all the necessary tools, compilers, and dependencies, and then share that container with teammates or deploy it in CI/CD pipelines. This approach eliminates the “it works on my machine” problem and is a staple in modern software development workflows.

GitHub Copilot, powered by AI, acts as a virtual pair programmer that can assist you in writing code, suggesting functions, and even generating boilerplate based on your comments and existing code. In C++—a language known for its complexity and verbosity—Copilot can be a huge productivity booster. It helps by generating repetitive code structures, offering context-aware suggestions, and reducing the time spent searching for syntax or patterns. While it doesn't replace the need for solid C++ knowledge, it can accelerate development and reduce mental overhead.

This course also dives into using Git for version control—a fundamental skill in any programming career—and demonstrates how to use Compiler Explorer, a handy online tool for trying out C++ snippets and viewing the resulting assembly code in real time. It’s perfect for learning, testing, and understanding how your code is interpreted by the compiler.

Whether you're a beginner looking to set up your first project or a professional aiming to streamline your workflow, this course offers a practical, up-to-date guide to mastering the tools the pros use in C++ development. It's a great way to build a solid foundation and level up your C++ skills in today’s multi-platform, AI-augmented development landscape.

Watch the full course on the freeCodeCamp.org YouTube channel (6-hour watch).

Along the way, you will learn about the flow of control, variables, conditional statements, loops, arrays, functions, structured data, pointers and dynamic memory, classes, common data structures, and working with databases.

Integrated Development Environments (IDE’s) are tools that allow you to write, run, and debug C++ programs. There are some great free C++ IDE’s out there.

If you own a Windows computer, I recommend using Visual Studio Community Edition. If you own a Mac, I recommend using Xcode. These provide robust features and excellent support for C++ development. If you're looking for a lightweight install on any platform, CLion is a fantastic choice.

For those who prefer not to install any software or are unable to, replit is a convenient web-based IDE that allows you to start coding immediately.

There are practice problems in each section so that you can use to practice while learning from the content. These are in the 'Hands-On Practice' portion of each section. You will use your IDE to write and run these practice programs.

Code Playbacks

This is not a traditional online tutorial or video series. Each section will have links to interactive ‘code playbacks’ that visually animate the changes made to a program in a step-by-step manner.

A code playback shows how a program evolves by replaying all the steps in its development. It has an author-supplied narrative, screenshots, whiteboard-style drawings, and self-grading multiple choice questions to make the learning process more dynamic and interactive. Just click on the numbered comments on the left hand side of the screen to drive the playback forward.

Watch this short YouTube video which explains how to view a code playback in more detail.

Playback Press

Playback Press is a platform for sharing code playbacks. The site contains collections of code playbacks grouped together by language/technology into different ‘books’. If you want to see the full C++ book, you can go here: An Animated Introduction to Programming in C++.

Code playbacks on the platform include AI tutoring, mini-quizzes, and text-to-speech features.

Storyteller is the free and open-source tool that powers code playbacks.

AI Tutor

When viewing a code playback, you can ask an AI tutor about the code. It answers questions clearly and patiently, making it a helpful resource for learners. You can also ask the AI tutor to generate new self-grading multiple choice questions to test your knowledge of what you are learning.

In order to access the AI tutor and to generate new multiple choice questions, simply create a free account on Playback Press and add the book to your bookshelf. It is still free, but you do need to register in order to access the AI features.

Table of Contents

• Part 1: Variables

• Part 2: Selection

• Part 3: Looping

• Part 4: Arrays

• Part 5: Functions

• Part 6: Vectors

• Part 7: Structured Data

• Part 8: Pointers

• Part 9: Object-Oriented Programming

• Part 10: Data Structures

• Part 11: SQLite Databases

• Comments and Feedback

C++ Overview

C++ is a powerful, high-performance programming language that is widely used in various domains such as system development, game development, real-time simulations, and high-performance applications. It is an extension of the C programming language, adding object-oriented features, which makes it suitable for large-scale software engineering projects.

C++ provides fine-grained control over system resources and memory management, which can lead to highly optimized and efficient code. C++ remains a popular choice due to its versatility, performance, and the vast ecosystem of libraries and tools available.

Part 1: Variables

Simply watching an experienced artist paint is not enough to say that you have learned how to become a painter. Watching an experienced artist is an important part of the learning process, but you can only call yourself a painter after struggling to make your own paintings first.

There are a lot of similarities between learning to paint and learning to program. The only way to truly learn programming is through practice!

So, let's get started. Follow along with the code playbacks below. Click the links below to load each code playback (it may help to open them in a new tab). Click on the playback comments on the left-hand side of the playback screen to step through the code's development.

Flow of Control

The following playback explains the flow of control in a program by describing how to print to the screen from it:

• 1.1 Name printer program

Variables and Types

This next group of programs describes declaring variables to hold data in a program. All variables have a type which specifies what can be stored in them and what operations can be performed on them.

• 1.2 Distance formula

• 1.3 Basic types in C++

• 1.4 Number types

• 1.5 Characters and strings

Reading from the Keyboard

This final group of programs builds on previous concepts and shows how to prompt the user for input.

• 1.6 Weekly pay calculator

• 1.7 Distance formula revisited

• 1.8 Gas Mileage

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program that prompts the user for three integers: one representing an hour, one representing a minute, and one representing a second. Next, calculate the number of seconds until midnight based on the time that was input. Print the number of seconds until midnight on the screen.

Then, prompt the user for a single integer representing the number of seconds until midnight. From that value, do the reverse calculation to find the hour, minute, and second of that time. Print it to the screen in a time format HH:MM:SS.

Part 2: Selection

This section discusses altering the flow of control with if/else statements. These statements ask the computer to evaluate whether a condition is true or false and changes the flow of control based on the answer. It also explains the data type, bool, which can hold either true or false and it shows a few examples of how to use selection with if, if/else, if/else if/else, and switch statements.

• 2.1 Booleans

• 2.2 Even/odd calculator

• 2.3 Overtime pay with an if/else

• 2.4 Water temperature

• 2.5 Switch

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, try to write a few programs:

Problem 1

Problem 1 asks you to write a program to determine if one date comes after another. The program will ask for two sets of dates. Next, the program will determine if the first date comes before, is equal to, or comes after.

Enter in the first month: 2
Enter in the first day: 21
Enter in the first year: 2012

Enter in the second month: 2
Enter in the second day: 22
Enter in the second year: 2011

The first date comes after the second.

Problem 2

Problem 2 asks you to write a program that prompts the user for a date and determines if that date is valid. For example, 9/19/2017 is a valid date, but these are not valid dates:

• 4/31/2006 (only 30 days in April)

• 2/29/2005 (not a leap year)

• 16/1/2010 (invalid month)

• 4/59/2013 (invalid day)

If the date is correct, print it out. If it is incorrect, display an error message explaining why the date is not correct.

Problem 3

Problem 3 asks you to write a program that will calculate change for a sales purchase. Your program should prompt for a sales price. Validate that the data entered is a number greater than 0. If the data entered is incorrect, display an error message and end the program.

Next, prompt the user for the amount that the customer will pay to the cashier. Validate that this value is greater than or equal to the sales price. If it is not, display an error message and end the program.

If the entry is correct, your program must calculate the amount of change to return to the user. Next, calculate what bills and coins that the the cashier needs to return to the customer. The fewest number of paper bills and coins should be returned. You can make change in many different combinations, but the only correct implementation is the one that returns the fewest paper bills and coins.

Display the number of each of the bills and coins. Here is a sample run of the program:

Enter in a sales amount: $20.38
Enter in the amount the customer pays: $30.00

The change due back is $9.62

You should give the customer this change:
0 $100 bills
0 $50 bills
0 $20 bills
0 $10 bills
1 $5 bills
4 $1 bills
1 Half Dollars
0 Quarters
1 Dimes
0 Nickels
2 Pennies

Because of the way arithmetic works with float variables, storing the monetary values as floats may cause some problems.

For example, if you had a float variable that held 1.29 to represent $1.29 and you subtracted the .05 from it (to represent giving back a nickel), you would think that you would be left with exactly 1.24. Unfortunately, the computer might store that value or it might store 1.2399999 or 1.2400001 instead of exactly 1.24.

These very small inconsistencies can cause a problem calculating the number of pennies to return. Consider converting the amounts into ints to solve this problem.

Part 3: Looping

This group of playbacks discusses repeatedly executing the same code over and over again in a loop. They show how to create count controlled and event controlled loops with the while keyword, nested loops, a for loop, and how to exit a loop with break and continue.

• 3.1 A simple loop

• 3.2 More loops

• 3.3 Summation

• 3.4 Nested loop

• 3.5 for loop

• 3.6 Capitalization

• 3.7 break and continue

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a few programs:

Problem 1

Problem 1 asks you to write a program that will calculate the sum of the squares from 1 up to and including that number. For example, if the user entered in the value 5, then the sum of the squares for the numbers one through five would be (1 + 4 + 9 + 16 + 25) = 55.

Your program should repeatedly calculate this value until the user enters in a value of -99. This is the sentinel value that the program uses to determine when to quit.

Enter in an integer number(ex. 10), -99 to quit: 5
The sum of the squares up to 5 is 55

Enter in an integer number(ex. 10), -99 to quit: 4
The sum of the squares up to 4 is 30

Enter in an integer number(ex. 10), -99 to quit: -99
Have a nice day!

Problem 2

Problem 2 asks you to write a program that will determine whether a number is prime or not. A prime number is any number that is evenly divisible only by the number one and itself.

7 is prime because the only numbers that divide into it without a remainder are 1 and 7.

12 is not prime because the numbers that divide into it evenly are 1, 2, 3, 4, 6, and 12.

Your program will prompt for a number and then display whether the number is prime or not. The number entered must be a positive number. Repeatedly prompt for a number until a positive number is entered.

Problem 3

Problem 3 asks you to calculate a mortgage schedule for someone thinking of buying a new house. The inputs to determine a monthly schedule are the principal loan amount and the annual interest rate. Assume this will be a conventional 30 year loan.

Your program should prompt for these inputs and find a monthly payment using this calculation:

                                   monthly interest rate                                              
monthly payment =  ------------------------------------------------- * principal
                   1 - (1 + monthly interest rate)^-number of months

Notice that you will have to calculate the monthly interest rate (the annual interest rate divided by 12.0) and number of months (360 for a 30 year loan). The ^ in this formula means raise one number to a power. There is a function called pow() which raises one number to another and returns the result. For example, if you wanted to raise 2 to the -3rd power, you would do this:

float result = pow(2.0, -3.0);

After you have calculated the monthly payment, create a summary of the loan characteristics. Display the loan amount, the interest rate, the monthly payment, the total amount paid for the loan, the total amount of interest paid, and the ratio of amount paid over the principal.

After you have printed the summary, you can begin to make the schedule. Prompt the user for the ending month to display in the schedule. The schedule should display the month number, the monthly payment, the amount paid in principal in that month, the amount paid in interest in that month, and the amount remaining in the principal (the amount paid in principle each month is deducted from the remaining principle). A month's interest amount is equal to monthly interest rate times the remaining principal. The monthly principal is the difference between the monthly payment and the monthly interest paid. Remember to update the remaining principal after every month.

After each year of the schedule has been printed, display a message with the year number.

Part 4: Arrays

This batch of programs shows how to use arrays in C/C++. An array is a collection of variables (all of the same type) that have a single name and sit next to each other in memory. Loops are almost always used to go through the elements of an array. They show how to create two and three dimensional arrays and use the random number generator in C/C++.

• 4.1 Arrays

• 4.2 Average and standard deviation of an array of values

• 4.3 Problems with arrays

• 4.4 Flipping coins

• 4.5 Multi-dimensional arrays

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a few programs:

Problem 1

Problem 1 asks you to write a program that displays a menu with three options.

The first option allows the user to enter in a month number (between 1-12) and a day number within that month (1-31) and calculates the day number in the year. January 1 is day 1. January 31 is day 31. February 1 is day 32. February 28 is day 59. December 31 is day 365 (don’t worry about leap years). If the user enters an invalid combination (like February 31) the program should continuously prompt the user to enter in a new value until they enter a valid date.

The second menu option allows the user to enter in a day number (1-365) and prints out the month name and day number of that month. If the user enters in 59, the program should print out:

Day 59 is February 28

If the user enters an invalid day number, the program should continuously prompt the user to enter in a new value until it is in the correct range.

The last menu option allows the user to quit the program. The menu should repeatedly be displayed until the user chooses to quit the program.

Use an array of integers to hold the number of days in each of the months. Use the array to keep a running sum to help with your day calculations. You may also want to create an array of strings with the month names.

int numDaysInMonths[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

Here is a sample run of the program:

1. Enter in a month and day
2. Enter in a day number
3. Quit
Enter in a menu option: 1

Enter in a month number: 2
Enter in a day number: 1

February 1 is day 32

1. Enter in a month and day
2. Enter in a day number
3. Quit
Enter in a menu option: 2

Enter in a day number: 59
Day 59 is February 28

1. Enter in a month and day
2. Enter in a day number
3. Quit
Enter in a menu option: 3

Problem 2

Problem 2 asks you to create a program that will find the number of days in between two dates.

For example, say a user would like to know how many days are in between two dates (1/1/2000) and (3/19/2030). The program must find out how many whole days are in between these two dates (include the starting and ending date).

If the two dates are in the same year, then the algorithm to find the number of days may be different than if the dates are in different years. Your program must handle each case.

Here is a sample run of the program:

Enter in a start month: 1
Enter in a start day: 1
Enter in a start year: 2000

Enter in an end month: 3
Enter in an end day: 19
Enter in an end year: 2030

There are 11035 days in between 1/1/2000 and 3/19/2030

Part 5: Functions

This group of playbacks describes another flow of control-altering mechanism called functions. A function is a named block of code that can be called and the flow of control will jump to it.

When calling a function, some data can be passed into it (called parameters) and the function can return a piece of data when it is complete (called a return value). These playbacks discuss passing in data 'by value' versus 'by reference'. They show that every variable has a limited lifetime that it sits in memory, or scope.

• 5.1 Functions

• 5.2 Value returning functions

• 5.3 Functions with parameters

• 5.4 Passing parameters by reference

• 5.5 The scope of variables

• 5.6 Prime number function

• 5.7 Passing arrays to functions

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a few programs:

Problem 1

Problem 1 asks you to extend the prime number problem from a previous section. Write a program that includes a function that will print all the prime numbers in a range. The program will ask for a lower bound and an upper bound and print all the primes in that range.

Problem 2

Problem 2 asks you to write a function that takes an integer year number and returns a bool whether that year is a leap year or not. The calculation for leap year is as follows:

• most years evenly divisible by four are leap years

• if a year is divisible by four and is a century year, like 1800 or 1900, then it is NOT a leap year

• if a century year also happens to be divisible by 400, like 2000 or 2400, then it is a leap year

The function should look something like this:

bool isLeapYear(int year)
{
    //calculate if it is leap year or not and return true or false
}

Problem 3

Problem 3 asks you to write a program that will print a calendar for a whole year given the day that January 1st falls on. Your program will prompt for the day that January 1st falls on and the year. You must print the calendar for all 12 months of that year. The options for the first day of the year will be entered with the first three letters of each of the seven days of the week from Sunday ('sun') to Saturday ('sat').

The year does not need to be validated, but the day of the week does. You should not allow the user to enter in a value other than 'sun', 'mon', 'tue', 'wed', 'thu', 'fri', or 'sat'.

The format of your calendar should be very similar to the example below. You must use at least one function in addition to the main function. Pass data between functions, do not use global variables.

The final requirement is that your program should only display one month at a time and then wait for some user input before continuing.

It is very important that you come up with a plan to solve this program before you begin coding (as it is with every program). Think about how you would print a single month's calendar given the day of the month that it begins on.

Sample Output:

What year do you want the calendar for?
2003

What day of the week does January 1st fall on (sun for Sunday, mon for Monday, etc..)?
s
Invalid Entry - please enter the first three letters of the day

What day of the week does January 1st fall on (sun for Sunday, mon for Monday, etc..)?
wed

    January 2003
 S  M  T  W  T  F  S
---------------------
          1  2  3  4
 5  6  7  8  9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31

Do you want to continue? y

   February 2003
 S  M  T  W  T  F  S
---------------------
                   1
 2  3  4  5  6  7  8
 9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28

Do you want to continue? y
...
...

Part 6: Vectors

C++ comes with the Standard Template Library (STL) which is a collection of different containers. This section will cover vectors. A vector is an array-based container that holds data very much like an array does but it is smarter. It knows how many elements are in it and it can grow as the program is running. It also shows how to read and write data from a file, efficiently search through an array-based container, sort values, and more.

• 6.1 vector

• 6.2 Passing a vector to a function

• 6.3 Advanced features of vectors

• 6.4 Reading from a file and storing in a vector

• 6.5 Linear search and binary search

• 6.6 Bubble sort

• 6.7 Writing to a file

• 6.8 Two dimensional vectors

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program to read in whole words from a file and store them in a vector of strings. Create a simple text file (.txt) using your coding editor. Then add a few sentences of text to it. Strip any punctuation marks from the words and make them all lowercase letters. Only store a word in the vector if it is not already present.

Part 7: Structured Data

This section describes how to use structured data types. Structured data types allow you to group related data together so that it can be passed around easily.

• 7.1 Simple struct

• 7.2 Hierarchical structs

• 7.3 vectors as members of structs

• 7.4 structs with a vector of objects

• 7.5 Calculus with structs

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program that has a struct to represent a cell phone. Every cell phone has a model name and manufacturer along with a camera with a mega-pixel resolution. For example, a user may want to store information about an Apple IPhone X with a 12 MP camera or a Google Pixel 4 with a 16 MP camera.

Your program will create three cell phone objects, fill them, and then add them to a vector. Lastly, print out the information about each cell phone on the screen.

Write a function that takes a cell phone object by reference and prompts the user to enter in the model, manufacturer, and camera resolution. Write another function that prints information about a cell phone. Write a function that takes a vector of cell phones and prints each one.

Part 8: Pointers

This section describes pointers in C/C++. A pointer is a variable that holds the address of another variable. Pointers are important because they allow us to use a special section of memory called the 'heap'. This section discusses the different types of memory that can be used in a program (global, local, and dynamic).

• 8.1 Simple pointers

• 8.2 Pointer to an object

• 8.3 Vectors of pointers

• 8.4 Arrays are pointers

• 8.5 Passing data to functions with pointers

• 8.6 Comparing pointers

• 8.7 Three types of variables- global, local, and dynamic

• 8.8 Dynamic variables example

• 8.9 Dangling pointers and null pointers

• 8.10 Dynamic array of students

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program that will read a sequence of words from the keyboard and store them in a dynamic array of strings. Use the word 'quit' as the word that terminates the input. Print the words back to the screen in the order in which they were entered, each on its own line. Do not store the same word twice.

Up until now, the size of an array has been determined at compile time. Now that you know about pointers and about the keyword new, write a program which is not restricted to selecting an upper bound at compile time for the number of words which can be read in.

One way to do this is to use new to create arrays of strings on the fly. Each time an array fills up, dynamically create an array which is twice as large, copy over the contents of the existing array to the new array, and continue (remember to delete the original array). Start with an array of 5 elements.

Here is an example of the output:

Enter in some text and end with the word quit:
This lab asks you to write a program that will read a sequence of words from the keyboard and store them in a dynamic array of strings. Use the word 'quit' as the word that terminates the input. Print the words back to the screen in the order in which they were entered each on its own line. Do not store the same word twice. quit

Doubling Array from 5 to 10
Doubling Array from 10 to 20
Doubling Array from 20 to 40
Doubling Array from 40 to 80
1. This
2. lab
3. asks
4. you
5. to
6. write
7. a
8. program
9. that
10. will
11. read
12. sequence
13. of
14. words
15. from
16. the
17. keyboard
18. and
19. store
20. them
21. in
22. dynamic
23. array
24. strings.
25. Use
26. word
27. 'quit'
28. as
29. terminates
30. input.
31. Print
32. back
33. screen
34. order
35. which
36. they
37. were
38. entered
39. each
40. on
41. its
42. own
43. line.
44. Do
45. not
46. same
47. twice.
Press any key to continue . . .

Part 9: Object-Oriented Programming

This section discusses object-oriented programming using classes in C++. A class is like a struct, except that in addition to collecting data, it also collects methods that work on that data. This is called encapsulation. It also discusses inheritance and polymorphism that make it easier to reuse code.

• 9.1 Simple class

• 9.2 A class with data members

• 9.3 A class with objects for data members

• 9.4 Common word analysis

• 9.5 Student and course registration system

• 9.6 Inheritance and polymorphism

• 9.7 Shape inheritance hierarchy

• 9.8 Inheritance and polymorphism in C++

• 9.9 Copy Constructor Example

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a few programs:

Problem 1

Problem 1 asks you to create a Date class to represent a date.

There should be an int for the day number, month number, and year number declared in the private section. Instead of having a setter for each of those, have one method called setDate(int m, int d, int y) that sets the date. You can have a getter method for each piece of data.

Add two constructors: one that takes no data and sets the date to 1/1/2000, and another that takes three ints to set the date.

Include a print() method that will print the date in this format: MM/DD/YYYY and a method called printLong() that prints in this format: MonthName Day, Year. For example, the first day of the 21st century should print January 1, 2000.

Include a method to add some number of days, months, and years to a Date:

void addDays(int d)
void addMonths(int m)
void addYears(int y)

Problem 2

Problem 2 asks you to create some related classes for playing card games. The data needed to be stored for a card is a numeric value and a suit. A card is responsible for being able to display itself. For example, when we want to display a two of hearts, ten of diamonds, jack of clubs, or ace of spades, the output would look like this:

2 of Hearts
10 of Diamonds
J of Clubs
A of Spades

Next, create a deck class. A deck is a collection of fifty-two cards. Each card is unique. There should be a card with a numeric value from two to the ace in each of the four suits. The responsibilities of the deck class are that it must be able to shuffle itself and deal out some number of cards from the deck. To shuffle the deck, you will need to randomly move cards around in the deck. You can generate a random number in C++ using the rand() function.

When dealing out cards, the user will ask the deck for some number of cards. If there are enough cards in the deck, it should deal those cards out. Once a card is dealt from the deck, it cannot be dealt again from the same deck. The user will pass in a vector of cards and the deck will fill it with the number of cards requested. If there aren't enough cards in the deck, print an error message and then kill the program with an exit(0).

When creating a class, you always have to think about the data needed for the class and the responsibilities of the class. The data for the class should be private and an interface to the class should be provided.

Think about how each card and deck should be constructed. Write at least one constructor for each class. Write the card class first and test it in a driver program. Then work on the deck class.

To test the deck, create a deck object, ask for 52 cards, and print each of those cards to the screen.

Next, alter the program so that it will allow a person to evaluate the probabilities of getting certain poker hands. Poker is a card game played with a deck of 52 cards. In this program, you only need to handle the five card variety of poker. The program will repeatedly get groups of five cards from the deck and count how many times each hand occurs.

In most variations of poker, the precedence of hands goes like this:

Royal Flush - 5 cards that are a straight (5 cards in numeric order) and a flush (5 cards that are the same suit) from the 10 to the Ace.
Straight Flush - 5 cards that are a straight (5 cards in numeric order) and a flush (5 cards that are the same suit).
Four of a Kind - any 4 cards with the same number.
Full House - three of a kind (3 cards with the same number) and a pair (two cards with the same number).
Flush - any 5 cards of the same suit.
Straight - any 5 cards in numeric order.
Three of a Kind - any 3 cards with the same number.
Two Pair - 2 sets of pairs.
Pair - any 2 cards with the same number.
High Card in your Hand - if you don't have any of the above, your high card is the best hand.

You will need to create additional classes with more responsibilities than the Deck and Card classes.

Your program needs an 'evaluator' that can look at a collection of cards and determine the best hand that can be made from those cards. In order to determine probabilities, deal a great number of hands and keep track of how many times each hand shows up.

In other words, your program might create 100,000 collections of five cards to be evaluated. The evaluator will count how many times a royal flush comes up, how many times a straight flush comes up, an so on. Your program will show the probabilities as percentages of the likelihood of getting each hand.

Below is a driver to illustrate how to use the evaluator:

int main()
{
    //five card evaluator
    //create a poker evaluator for 5 card poker
    PokerEvaluator fiveCardPokerEvaluator;

    //set the number of hands to play - one hundred thousand this time
    fiveCardPokerEvaluator.setNumberOfHandsToPlay(100000);

    //play all the hands and track the statistics, then print the results to the screen
    fiveCardPokerEvaluator.playAndDisplay();

    return 0;
}

Part 10: Data Structures

This section describes how to build some common data structures: a hash table, a binary search tree, and a graph. It also describes how to use the STL unordered_map class.

• 10.1 Simple linked list

• 10.2 Simple hash table

• 10.3 More complex hash table

• 10.4 STL unordered_map

• 10.5 Binary search tree

• 10.6 Graph adjacency matrix

Hands-On Practice

Now that you have reviewed the guided code walk-throughs, write a program that includes a class which is equivalent of the vector called SafeArray. SafeArray has a method called at that returns the element at the specified position.

A SafeArray maintains a pointer to an array on the heap. Use the pointer to make the array grow and shrink with calls to push_back and pop_back.

The SafeArray will have a method called size that returns the number of items in it. Include a default constructor that sets the initial size of the underlying array to hold 10 elements. Include a destructor to delete the array when the SafeArray falls out of scope.

Part 11: SQLite Databases

This section describes working with a SQLite database. SQLite is my favorite Database Management System (DBMS), because it is powerful and easy to add to any program. This section assumes that you are familiar with relational database design and SQL.

The first program shows how to use the API to write and run SQL queries in a C++ program. In the second, some of the repetitive code is abstracted into a separate class. In the third, transactions in SQLite are explained and it shows that they can be used to ensure the ACID properties of a database:

• 11.1 The C++ SQLite API

• 11.2 An Object Oriented Auction Program

• 11.3 SQLite Transactions

Hands-On Practice

Extend the auction program from the second playback to include a method that prints the names and email addresses of all of the users who won an auction. Then write a method that prints an item followed by the names and email addresses of anyone who made a bid on the item.

Comments and Feedback

You can find all of these code playbacks in my free book, An Animated Introduction to Programming in C++. There are more free books here:

• An Animated Introduction to Programming with Python

• Database Design and SQL for Beginners

• Worked SQL Examples

• Programming with SQLite

• An Introduction to Web Development from Back to Front

• An Animated Introduction to Clojure

• An Animated Introduction to Elixir

• A Brief Introduction to Ruby

• Mobile App Development with Dart and Flutter

• OO Design Patterns with Java

• How I Built It: Word Zearch

Comments and feedback are welcome via email: mark@playbackpress.com.

If you'd like to support my work and help keep Playback Press free for all, consider donating using GitHub Sponsors. I use all of the donations for hosting costs. Your support helps me continue creating educational content like this. Thank you!