Zig 언어 입문 — C의 대안이 될 수 있을까

Zig의 핵심 특징 — C와 무엇이 다른가

Zig 기본 문법 — Hello World와 기본 구조
// hello.zig
const std = @import("std");

pub fn main() !void {
    // !void = 에러가 발생할 수 있는 void 반환 타입
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {s}!\n", .{"Zig"});
    // try = 에러 발생 시 즉시 반환 (에러 무시 불가)
}

// 빌드 및 실행
// zig build-exe hello.zig
// zig run hello.zig

// 기본 변수와 타입
const x: i32 = 42;          // 상수 (불변)
var y: f64 = 3.14;           // 변수 (가변)
const name: []const u8 = "Zig"; // 문자열 슬라이스

// 배열과 슬라이스
const arr = [_]i32{ 1, 2, 3, 4, 5 }; // 크기 자동 추론
const slice: []const i32 = arr[1..4]; // [2, 3, 4]

// 구조체
const Point = struct {
    x: f32,
    y: f32,

    pub fn distance(self: Point, other: Point) f32 {
        const dx = self.x - other.x;
        const dy = self.y - other.y;
        return @sqrt(dx * dx + dy * dy);
    }
};

const p1 = Point{ .x = 0, .y = 0 };
const p2 = Point{ .x = 3, .y = 4 };
const dist = p1.distance(p2); // 5.0

comptime — 매크로 없이 컴파일 타임 프로그래밍

comptime — 제네릭과 컴파일 타임 계산
const std = @import("std");

// comptime 제네릭 함수 — 타입을 인자로 받음
fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

// 사용 — 런타임 오버헤드 없음, 각 타입별 코드 생성
const m1 = max(i32, 10, 20);   // 20
const m2 = max(f64, 3.14, 2.7); // 3.14

// comptime 스택 — 컴파일 타임에 크기가 결정되는 배열
fn makeArray(comptime size: usize) [size]i32 {
    var result: [size]i32 = undefined;
    for (&result, 0..) |*item, i| {
        item.* = @intCast(i * i);
    }
    return result;
}

const squares = makeArray(5); // [0, 1, 4, 9, 16] — 컴파일 타임 계산

// comptime 조건부 컴파일 (C의 #ifdef 대체)
const builtin = @import("builtin");
fn platformSpecific() void {
    if (comptime builtin.target.os.tag == .linux) {
        // Linux 전용 코드
    } else if (comptime builtin.target.os.tag == .macos) {
        // macOS 전용 코드
    }
    // 해당 없는 분기는 컴파일에서 완전히 제거됨
}

메모리 안전성 — Zig의 접근 방식

Zig 메모리 관리 — Allocator와 에러 처리
const std = @import("std");

// Allocator를 인자로 받는 함수 패턴
fn readFileContents(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
    const file = try std.fs.cwd().openFile(path, .{});
    defer file.close(); // defer: 스코프 종료 시 실행 보장

    const size = try file.getEndPos();
    const buffer = try allocator.alloc(u8, size);
    errdefer allocator.free(buffer); // 에러 시에만 해제

    _ = try file.readAll(buffer);
    return buffer; // 호출자가 해제 책임
}

pub fn main() !void {
    // GeneralPurposeAllocator — 디버그 빌드에서 메모리 누수 탐지
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit(); // 종료 시 누수 검사
    const allocator = gpa.allocator();

    const contents = try readFileContents(allocator, "README.md");
    defer allocator.free(contents); // 명시적 해제

    std.debug.print("{s}\n", .{contents});
}

// 옵셔널 타입 — null 안전성
fn findUser(id: u32) ?User {
    if (id == 0) return null;
    return User{ .id = id, .name = "Alice" };
}

const user = findUser(1) orelse return error.UserNotFound;
// orelse로 null 케이스 명시적 처리

C 호환성 — FFI 없이 C 라이브러리 사용

C 헤더 직접 사용 및 Zig를 C 컴파일러로 활용
// C 라이브러리 직접 사용 — bindings 불필요
const c = @cImport({
    @cInclude("stdio.h");
    @cInclude("sqlite3.h");
});

pub fn main() void {
    _ = c.printf("Hello from C printf!\n");

    var db: ?*c.sqlite3 = null;
    const rc = c.sqlite3_open(":memory:", &db);
    if (rc != c.SQLITE_OK) {
        c.sqlite3_close(db);
        return;
    }
    defer _ = c.sqlite3_close(db);
    // C API를 그대로 Zig에서 호출
}

// zig cc — 기존 C 프로젝트 크로스 컴파일
// $ zig cc -target x86_64-linux-musl main.c -o main-linux
// $ zig cc -target aarch64-macos main.c -o main-macos
// $ zig cc -target wasm32-freestanding main.c -o main.wasm

// build.zig — C 소스 포함 빌드
const std = @import("std");
pub fn build(b: *std.Build) void {
    const exe = b.addExecutable(.{
        .name = "myapp",
        .root_source_file = b.path("src/main.zig"),
        .target = b.standardTargetOptions(.{}),
    });
    // C 소스 직접 포함
    exe.addCSourceFile(.{ .file = b.path("vendor/lib.c") });
    exe.linkLibC();
    b.installArtifact(exe);
}

실제 사용 사례 — Bun과 TigerBeetle

현재 상태 — 도입 전 알아야 할 것