内存分配器 #

const std = @import("std");

pub fn main() !void {
    // 使用页面分配器
    const allocator = std.heap.page_allocator;
    
    // 分配内存
    const buffer = try allocator.alloc(u8, 100);
    defer allocator.free(buffer);
    
    // 使用内存
    for (buffer, 0..) |*b, i| {
        b.* = @intCast(i % 256);
    }
    
    std.debug.print("Allocated {} bytes\n", .{buffer.len});
}

const std = @import("std");

pub fn main() !void {
    const allocator = std.heap.page_allocator;
    
    // 分配切片
    const slice = try allocator.alloc(i32, 10);
    defer allocator.free(slice);
    
    // 分配单个对象
    const ptr = try allocator.create(i32);
    defer allocator.destroy(ptr);
    ptr.* = 42;
    
    // 重新分配
    var buffer = try allocator.alloc(u8, 10);
    buffer = try allocator.realloc(buffer, 20);
    defer allocator.free(buffer);
    
    std.debug.print("ptr.* = {}\n", .{ptr.*});
    std.debug.print("buffer.len = {}\n", .{buffer.len});
}

const std = @import("std");

pub fn main() !void {
    const allocator = std.heap.page_allocator;
    
    const buffer = try allocator.alloc(u8, 4096);
    defer allocator.free(buffer);
    
    std.debug.print("Allocated {} bytes\n", .{buffer.len});
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    const buffer = try allocator.alloc(u8, 100);
    defer allocator.free(buffer);
    
    std.debug.print("Allocated {} bytes\n", .{buffer.len});
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    
    var arena = std.heap.ArenaAllocator.init(gpa.allocator());
    defer arena.deinit();
    const allocator = arena.allocator();
    
    // 多次分配
    const a = try allocator.alloc(u8, 100);
    const b = try allocator.alloc(u8, 200);
    const c = try allocator.alloc(u8, 300);
    
    _ = a;
    _ = b;
    _ = c;
    
    // 不需要单独释放，arena.deinit() 会一次性释放
    std.debug.print("Arena allocations done\n", .{});
}

const std = @import("std");

pub fn main() !void {
    var buffer: [1024]u8 = undefined;
    var fba = std.heap.FixedBufferAllocator.init(&buffer);
    const allocator = fba.allocator();
    
    const data = try allocator.alloc(u8, 100);
    defer allocator.free(data);
    
    std.debug.print("Allocated {} bytes from buffer\n", .{data.len});
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    // 分配切片
    const numbers = try allocator.alloc(i32, 10);
    defer allocator.free(numbers);
    
    // 初始化
    for (numbers, 0..) |*n, i| {
        n.* = @intCast(i);
    }
    
    std.debug.print("numbers: {any}\n", .{numbers});
}

const std = @import("std");

const Node = struct {
    value: i32,
    next: ?*Node,
};

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    // 创建单个对象
    const node = try allocator.create(Node);
    defer allocator.destroy(node);
    
    node.* = .{ .value = 42, .next = null };
    
    std.debug.print("node.value = {}\n", .{node.value});
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();
    
    var buffer = try allocator.alloc(u8, 10);
    
    // 扩展
    buffer = try allocator.realloc(buffer, 20);
    
    // 缩小
    buffer = try allocator.realloc(buffer, 5);
    
    defer allocator.free(buffer);
    
    std.debug.print("buffer.len = {}\n", .{buffer.len});
}

const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer {
        const leaked = gpa.deinit();
        if (leaked == .leak) {
            std.debug.print("Memory leak detected!\n", .{});
        }
    }
    const allocator = gpa.allocator();
    
    const buffer = try allocator.alloc(u8, 100);
    defer allocator.free(buffer);
    
    std.debug.print("No leaks here\n", .{});
}

const std = @import("std");

fn DynamicArray(comptime T: type) type {
    return struct {
        items: []T,
        len: usize,
        allocator: std.mem.Allocator,
        
        const Self = @This();
        
        fn init(allocator: std.mem.Allocator) Self {
            return .{
                .items = &.{},
                .len = 0,
                .allocator = allocator,
            };
        }
        
        fn deinit(self: *Self) void {
            if (self.items.len > 0) {
                self.allocator.free(self.items);
            }
        }
        
        fn append(self: *Self, item: T) !void {
            if (self.len >= self.items.len) {
                const new_cap = if (self.items.len == 0) 4 else self.items.len * 2;
                var new_items = try self.allocator.alloc(T, new_cap);
                @memcpy(new_items[0..self.len], self.items[0..self.len]);
                if (self.items.len > 0) {
                    self.allocator.free(self.items);
                }
                self.items = new_items;
            }
            self.items[self.len] = item;
            self.len += 1;
        }
        
        fn get(self: Self, index: usize) ?T {
            if (index >= self.len) return null;
            return self.items[index];
        }
    };
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    
    var list = DynamicArray(i32).init(gpa.allocator());
    defer list.deinit();
    
    try list.append(1);
    try list.append(2);
    try list.append(3);
    
    for (0..list.len) |i| {
        std.debug.print("list[{}] = {}\n", .{ i, list.get(i).? });
    }
}