システムプログラマーのためのZig: 明示的なメモリアロケーター、Comptime、C ABI相互運用

const std = @import("std");

fn divide(numerator: f32, denominator: f32) !f32 {
    if (denominator == 0.0) {
        return error.DivideByZero;
    }
    return numerator / denominator;
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    const result1 = divide(10.0, 2.0);
    switch (result1) {
        .error => |err| {
            try stdout.print("Error: {any}\n", .{err});
        },
        .value => |val| {
            try stdout.print("Result 1: {d}\n", .{val});
        },
    }

    // Shorthand for error propagation
    const result2 = try divide(10.0, 5.0);
    try stdout.print("Result 2: {d}\n", .{result2});

    // Handling a potential error directly
    const result3 = divide(10.0, 0.0);
    if (result3) |val| {
        _ = val; // Value is available here, but we expect an error
        std.debug.print("This should not be reached.\n", .{});
    } else |err| {
        try stdout.print("Caught expected error: {any}\n", .{err});
    }
}

// Simplified representation of std.mem.Allocator
pub const Allocator = struct {
    ptr: *anyopaque, // Pointer to the allocator's internal state
    vtable: *const VTable, // Pointer to the virtual table of functions

    pub const VTable = struct {
        allocFn: *const fn (ptr: *anyopaque, len: usize, ptr_align: u2, ret_align: u2, zero_fill: bool, src_ptr: ?*anyopaque, src_len: usize) ?*anyopaque,
        resizeFn: *const fn (ptr: *anyopaque, old_mem: *anyopaque, old_len: usize, old_align: u2, new_len: usize, new_align: u2, zero_fill: bool, src_ptr: ?*anyopaque, src_len: usize) bool,
        freeFn: *const fn (ptr: *anyopaque, old_mem: *anyopaque, old_len: usize, old_align: u2) void,
        // ... other functions like shrink, alignedAlloc, etc.
    };
    // ... helper methods like .alloc, .free, .realloc
};

const std = @import("std");

// A simple struct to allocate
const MyData = struct {
    id: u32,
    name: []const u8,
};

pub fn main() !void {
    // 1. GeneralPurposeAllocator (GPA) for long-lived allocations
    var gpa_state = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa_state.deinit(); // Ensure GPA resources are freed
    const gpa = gpa_state.allocator();

    // Allocate a MyData struct using GPA
    var data_ptr = try gpa.create(MyData);
    defer gpa.destroy(data_ptr); // Ensure data_ptr is freed

    data_ptr.id = 1;
    data_ptr.name = try gpa.dupe(u8, "GPA Allocated String"); // Allocate string using GPA
    defer gpa.free(data_ptr.name);

    std.debug.print("GPA Data: ID={d}, Name='{s}'\n", .{ data_ptr.id, data_ptr.name });

    // 2. ArenaAllocator for temporary, scoped allocations
    var arena_state = std.heap.ArenaAllocator.init(gpa); // Arena uses GPA for its internal buffer
    defer arena_state.deinit(); // Frees the entire arena buffer
    const arena = arena_state.allocator();

    // Allocate a temporary string using the arena
    const temp_string = try arena.dupe(u8, "Arena Temp String");
    std.debug.print("Arena Temp String: '{s}'\n", .{ temp_string });

    // Allocate an array of integers in the arena
    const int_array = try arena.alloc(u32, 5);
    for (0..5) |i| {
        int_array[i] = @intCast(u32, i * 10);
    }
    std.debug.print("Arena Int Array: {any}\n", .{int_array});

    // When arena_state.deinit() is called (via defer), temp_string and int_array are freed.
    // No need for individual frees for arena allocations.

    // Demonstrate a function taking an allocator
    try processData(gpa, "Hello from GPA!");
    try processData(arena, "Hello from Arena!");
}

fn processData(allocator: std.mem.Allocator, message: []const u8) !void {
    const buffer = try allocator.alloc(u8, message.len + 1);
    defer allocator.free(buffer); // Important: free if not an arena

    @memcpy(buffer, message);
    buffer[message.len] = 0; // Null terminate for C-style string if needed

    std.debug.print("Processed message (via {s} allocator): '{s}'\n", .{
        if (allocator.ptr == std.heap.GeneralPurposeAllocator(.{}).allocator().ptr) "GPA" else "Arena", // Simplified check
        buffer
    });
}

const std = @import("std");

// A comptime function that operates on types
fn typeName(comptime T: type) []const u8 {
    return @typeName(T);
}

// A generic function that works with any type T
fn printValue(comptime T: type, value: T) void {
    std.debug.print("Value of type {s}: {any}\n", .{ typeName(T), value });
}

// A comptime generic struct
fn DynamicArray(comptime T: type) type {
    return struct {
        items: []T,
        capacity: usize,
        len: usize,
        allocator: std.mem.Allocator,

        pub fn init(allocator: std.mem.Allocator, initial_capacity: usize) !@This() {
            const buffer = try allocator.alloc(T, initial_capacity);
            return .{
                .items = buffer,
                .capacity = initial_capacity,
                .len = 0,
                .allocator = allocator,
            };
        }

        pub fn deinit(self: *@This()) void {
            self.allocator.free(self.items);
            self.* = undefined; // Invalidate the struct
        }

        pub fn append(self: *@This(), item: T) !void {
            if (self.len == self.capacity) {
                try self.grow();
            }
            self.items[self.len] = item;
            self.len += 1;
        }

        fn grow(self: *@This()) !void {
            const new_capacity = if (self.capacity == 0) 1 else self.capacity * 2;
            self.items = try self.allocator.realloc(self.items, new_capacity);
            self.capacity = new_capacity;
        }
    };
}

pub fn main() !void {
    printValue(u32, 123);
    printValue(f32, 45.67);
    printValue([]const u8, "Hello, Comptime!");

    var gpa_state = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa_state.deinit();
    const gpa = gpa_state.allocator();

    // Instantiate DynamicArray for u32
    var int_array = try DynamicArray(u32).init(gpa, 2);
    defer int_array.deinit();

    try int_array.append(10);
    try int_array.append(20);
    try int_array.append(30); // Will trigger a grow operation

    std.debug.print("Int Array: {any}, Length: {d}, Capacity: {d}\n", .{ int_array.items[0..int_array.len], int_array.len, int_array.capacity });

    // Instantiate DynamicArray for []const u8
    var string_array = try DynamicArray([]const u8).init(gpa, 1);
    defer string_array.deinit();

    try string_array.append("First");
    try string_array.append("Second");

    std.debug.print("String Array: {any}, Length: {d}, Capacity: {d}\n", .{ string_array.items[0..string_array.len], string_array.len, string_array.capacity });
}

// c_example.h
#ifndef C_EXAMPLE_H
#define C_EXAMPLE_H

#include <stdint.h> // For int32_t

// A simple C function
int32_t add_numbers(int32_t a, int32_t b);

// A C function that takes a string and returns a new string (caller owns memory)
char* reverse_string(const char* input);

// A C function that takes a callback
typedef void (*callback_fn)(int32_t value);
void process_with_callback(int32_t start, int32_t end, callback_fn cb);

#endif // C_EXAMPLE_H

// c_example.c
#include "c_example.h"
#include <stdlib.h>
#include <string.h>

int32_t add_numbers(int32_t a, int32_t b) {
    return a + b;
}

char* reverse_string(const char* input) {
    size_t len = strlen(input);
    char* reversed = (char*)malloc(len + 1);
    if (!reversed) return NULL;

    for (size_t i = 0; i < len; ++i) {
        reversed[i] = input[len - 1 - i];
    }
    reversed[len] = '\0';
    return reversed;
}

void process_with_callback(int32_t start, int32_t end, callback_fn cb) {
    for (int32_t i = start; i <= end; ++i) {
        cb(i);
    }
}

// main.zig
const std = @import("std");

// Import C header. This makes C functions and types available in Zig.
// The `c_example.h` file must be accessible to the Zig compiler.
// Use `zig build-exe main.zig c_example.c -lc` to compile.
const c = @cImport({
    @cInclude("c_example.h");
});

// A Zig function to be used as a C callback
export fn zig_callback(value: c_int) void {
    std.debug.print("Zig callback received: {d}\n", .{value});
}

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();

    // Call a C function directly
    const sum = c.add_numbers(10, 20);
    try stdout.print("Sum from C: {d}\n", .{sum});

    // Call a C function that returns a C string
    const original_string = "Hello Zig";
    const reversed_c_string = c.reverse_string(original_string);
    if (reversed_c_string == null) {
        return error.MemoryAllocationFailed;
    }
    defer c.free(reversed_c_string); // Remember to free C-allocated memory!

    // Convert C string to Zig slice
    const reversed_zig_slice = std.mem.span(reversed_c_string);
    try stdout.print("Reversed string from C: '{s}'\n", .{reversed_zig_slice});

    // Call a C function that takes a Zig callback
    try stdout.print("Calling C function with Zig callback...\n", .{});
    c.process_with_callback(1, 3, zig_callback);
    try stdout.print("C function with Zig callback finished.\n", .{});
}

// zig_library.zig
const std = @import("std");

// Export a Zig function to be callable from C
export fn zig_add(a: i32, b: i32) i32 {
    return a + b;
}

// Export a Zig function that allocates memory and returns a C string
// C caller is responsible for freeing this memory using zig_free_string.
export fn zig_create_message(allocator: std.mem.Allocator, value: i32) ?*const u8 {
    const message = std.fmt.allocPrint(allocator, "Value is: {d}", .{value}) catch return null;
    return message.ptr; // Return raw pointer
}

// A function to free memory allocated by zig_create_message
export fn zig_free_string(allocator: std.mem.Allocator, ptr: ?*const u8, len: usize) void {
    if (ptr) |p| {
        allocator.free(p[0..len]);
    }
}

// zig_library.h (generated)
#include <stdint.h>

// Forward declare std.mem.Allocator if needed, or pass a raw pointer
// For simplicity, we'll assume the C side passes a compatible allocator context.
// In a real scenario, you'd likely pass a void* and cast it in Zig.

extern int32_t zig_add(int32_t a, int32_t b);
extern const uint8_t* zig_create_message(void* allocator_ptr, int32_t value);
extern void zig_free_string(void* allocator_ptr, const uint8_t* ptr, uintptr_t len);

#include <stdio.h>
#include <stdlib.h> // For atoi

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <N>\n", argv[0]);
        return 1;
    }
    long long n = atoll(argv[1]);
    long long sum = 0;
    for (long long i = 1; i <= n; ++i) {
        sum += i;
    }
    printf("Sum: %lld\n", sum);
    return 0;
}

const std = @import("std");

pub fn main() !void {
    const args = try std.process.argsAlloc(std.heap.page_allocator);
    defer std.process.argsFree(std.heap.page_allocator, args);

    if (args.len < 2) {
        std.debug.print("Usage: {s} <N>\n", .{args[0]});
        return error.InvalidUsage;
    }

    const n_str = args[1];
    const n = try std.fmt.parseInt(u64, n_str, 10);

    var sum: u64 = 0;
    for (1..n + 1) |i| {
        sum += i;
    }
    std.debug.print("Sum: {d}\n", .{sum});
}