Shopping Cart - Zig Typing CST Test

Mode:

Duration:

const std = @import("std");
var items: [5]?[]const u8 = [_]?[]const u8{null} ** 5;
var prices: [5]f64 = [_]f64{0} ** 5;
var count: usize = 0;
var total: f64 = 0;

fn addItem(item: []const u8, price: f64) void {
	if (count < items.len) {
		items[count] = item;
		prices[count] = price;
		total += price;
		count += 1;
	}
}

fn removeItem(index: usize) void {
	if (index < count) {
		total -= prices[index];
		for (index..count-1) |i| {
		items[i] = items[i+1];
		prices[i] = prices[i+1];
		}
		count -= 1;
	}
}

fn printCart() void {
	for (0..count) |i| {
		std.debug.print("{s}: ${f}\n", .{items[i], prices[i]});
	}
	std.debug.print("Total: ${f}\n----------------\n", .{total});
}

pub fn main() void {
	addItem("Apple", 2.0);
	addItem("Banana", 3.0);
	printCart();
	removeItem(0);
	printCart();
}Coding works best on desktop or with an external keyboard.

Shopping Cart — Zig Code

Adds and removes items in a shopping cart with total cost.

const std = @import("std");
var items: [5]?[]const u8 = [_]?[]const u8{null} ** 5;
var prices: [5]f64 = [_]f64{0} ** 5;
var count: usize = 0;
var total: f64 = 0;

fn addItem(item: []const u8, price: f64) void {
	if (count < items.len) {
		items[count] = item;
		prices[count] = price;
		total += price;
		count += 1;
	}
}

fn removeItem(index: usize) void {
	if (index < count) {
		total -= prices[index];
		for (index..count-1) |i| {
		items[i] = items[i+1];
		prices[i] = prices[i+1];
		}
		count -= 1;
	}
}

fn printCart() void {
	for (0..count) |i| {
		std.debug.print("{s}: ${f}\n", .{items[i], prices[i]});
	}
	std.debug.print("Total: ${f}\n----------------\n", .{total});
}

pub fn main() void {
	addItem("Apple", 2.0);
	addItem("Banana", 3.0);
	printCart();
	removeItem(0);
	printCart();
}

Zig Language Guide

Zig is a general-purpose, statically typed, compiled programming language designed for robustness, optimal performance, and simplicity. It emphasizes manual memory management, safety features, cross-compilation, and direct interoperability with C, making it ideal for system programming, embedded development, and high-performance applications.

Primary Use Cases

▸System programming and OS development
▸Embedded and bare-metal applications
▸High-performance libraries and tools
▸Cross-platform and cross-compiler projects
▸Interfacing with C libraries and APIs

Notable Features

▸Manual memory management with safety
▸Comptime (compile-time) execution
▸Direct C interoperability
▸Error unions and optional types
▸Cross-compilation built-in

Origin & Creator

Created by Andrew Kelley in 2015 with the goal of replacing C while providing safer and more readable system programming constructs.

Industrial Note

Zig is gaining traction in system-level programming, embedded device firmware, WebAssembly development, game engine tooling, and low-level networking applications.

Quick Explain

▸Zig is a compiled language that provides fine-grained control over memory and system resources.
▸It combines simplicity with modern safety features like optional types and error handling.
▸Commonly used in operating systems, game engines, embedded systems, and performance-critical applications.

Core Features

▸Statically typed with no hidden control flow
▸Comptime metaprogramming
▸Direct access to pointers and memory
▸Simple syntax for performance and clarity
▸No hidden allocations or runtime surprises

Learning Path

▸Learn basic syntax and data types
▸Understand slices, structs, and pointers
▸Practice error unions and optional types
▸Use `comptime` for compile-time code
▸Explore C interop and cross-compilation

Practical Examples

▸Writing a custom memory allocator
▸Creating a cross-platform CLI tool
▸Interfacing with a C library
▸Developing a small embedded firmware
▸Implementing a high-performance networking server

Comparisons

▸More memory-safe than C, less than Rust
▸Simpler syntax than C++
▸Cross-compilation easier than Go or Rust
▸Less standard library than C++ or Rust
▸Closer to hardware than Python or Java

Strengths

▸High performance and predictable behavior
▸Minimal runtime overhead
▸Cross-platform compilation support
▸Strong C interop for library reuse
▸Compile-time code execution for flexibility

Limitations

▸Smaller ecosystem than C/C++ or Rust
▸No garbage collector; manual memory management required
▸Limited standard library compared to mature languages
▸Fewer learning resources and tutorials
▸Some advanced abstractions require verbose code

When NOT to Use

▸Rapid application development
▸Garbage-collected environments
▸Large ecosystem libraries required
▸UI-heavy applications
▸Managed runtime platforms

Cheat Sheet

▸var x: i32 = 42 - declare variable
▸fn add(a: i32, b: i32) i32 { return a+b; } - function
▸const slice = []u8{1,2,3} - array/slice
▸errdefer mem.free(ptr) - error-safe cleanup
▸comptime { ... } - compile-time execution

FAQ

▸Is Zig production-ready?
▸Yes - suitable for systems programming and embedded projects.
▸Can Zig replace C?
▸It can in many scenarios, with safer and modern syntax.
▸Does Zig have a garbage collector?
▸No - manual memory management is used.
▸Is Zig cross-platform?
▸Yes - built-in cross-compilation for many targets.
▸Is Zig suitable for beginners?
▸Yes, for systems programming basics, though low-level concepts are required.

30-Day Skill Plan

▸Week 1: Syntax, variables, functions
▸Week 2: Pointers, slices, memory management
▸Week 3: Error unions and optional types
▸Week 4: Comptime metaprogramming
▸Week 5: Cross-compilation and C integration

Final Summary

▸Zig is a modern system programming language designed for safety, performance, and simplicity.
▸It excels at low-level programming, embedded development, and cross-platform compilation.
▸Zig combines C interoperability, manual memory management, and compile-time code execution.
▸Ideal for developers who want control over performance and hardware without unnecessary runtime overhead.

Project Structure

▸src/ - source code files
▸build.zig - build configuration script
▸tests/ - test files
▸lib/ - optional libraries
▸bin/ - compiled executables

Monetization

▸Commercial libraries
▸Embedded firmware products
▸High-performance computing tools
▸CLI utility software
▸Game engine components

Productivity Tips

▸Use `zig fmt` for consistent formatting
▸Leverage `comptime` for compile-time checks
▸Test code frequently with `zig test`
▸Cross-compile regularly to verify targets
▸Document error unions and memory usage

Basic Concepts

▸Comptime code execution
▸Error unions and error handling
▸Optional types and pointer management
▸Slices, arrays, and structs
▸Direct C interoperability

Official Docs

▸Zig Official Documentation
▸Zig Learn Page
▸Zig GitHub Repository

More Zig Typing Exercises

Zig Counter and Theme Toggle Zig Random Number Generator Zig Todo List Zig Dice Roller Zig Countdown Timer Zig Prime Checker Zig Temperature Converter Zig Name Greeting Zig Stopwatch

Practice Other Languages

C React Python C++Rust TypeScript Kotlin PHP Java C#Ruby Mql Cql N1ql Cypher

Coding works best on desktop or with an external keyboard.

Shopping Cart — Zig Code

Adds and removes items in a shopping cart with total cost.

Zig Language Guide

Primary Use Cases

▸System programming and OS development
▸Embedded and bare-metal applications
▸High-performance libraries and tools
▸Cross-platform and cross-compiler projects
▸Interfacing with C libraries and APIs

Notable Features

▸Manual memory management with safety
▸Comptime (compile-time) execution
▸Direct C interoperability
▸Error unions and optional types
▸Cross-compilation built-in

Origin & Creator

Created by Andrew Kelley in 2015 with the goal of replacing C while providing safer and more readable system programming constructs.

Industrial Note

Zig is gaining traction in system-level programming, embedded device firmware, WebAssembly development, game engine tooling, and low-level networking applications.