usize em Zig — O que é e Como Usar

Definição

usize é o tipo inteiro sem sinal (unsigned) cujo tamanho corresponde ao tamanho nativo de um ponteiro na arquitetura-alvo. Em sistemas de 64 bits, usize tem 64 bits (8 bytes); em sistemas de 32 bits, tem 32 bits (4 bytes). É o tipo padrão para indexação de arrays, comprimento de slices e aritmética de ponteiros.

Em termos práticos, usize é equivalente ao size_t do C.

Por que usize Importa

1. Indexação: Todo acesso a arrays e slices em Zig usa usize como tipo de índice.
2. Tamanhos: O campo .len de slices e arrays retorna usize.
3. Portabilidade: Garante que o código funcione em arquiteturas de 32 e 64 bits sem alteração.
4. Aritmética de ponteiros: Operações de ponteiro usam usize para deslocamentos.

Exemplo Prático

Indexação de Arrays e Slices

const std = @import("std");

pub fn main() void {
    const dados = [_]u8{ 10, 20, 30, 40, 50 };

    // .len retorna usize
    const tamanho: usize = dados.len;
    std.debug.print("Tamanho: {}\n", .{tamanho}); // 5

    // Índice de iteração é usize
    for (dados, 0..) |valor, i| {
        std.debug.print("[{}] = {}\n", .{ i, valor });
    }
}

Conversão entre Tipos Inteiros

const std = @import("std");

fn buscar(slice: []const u8, indice: usize) ?u8 {
    if (indice >= slice.len) return null;
    return slice[indice];
}

pub fn main() void {
    const dados = [_]u8{ 'Z', 'i', 'g' };

    // Converter u32 para usize com @intCast
    const pos: u32 = 1;
    const resultado = buscar(&dados, @intCast(pos));

    if (resultado) |byte| {
        std.debug.print("Encontrado: {c}\n", .{byte}); // 'i'
    }
}

Tamanho em Bytes com @sizeOf

const std = @import("std");

pub fn main() void {
    std.debug.print("usize = {} bytes\n", .{@sizeOf(usize)});   // 8 em 64-bit
    std.debug.print("isize = {} bytes\n", .{@sizeOf(isize)});   // 8 em 64-bit
    std.debug.print("*u8   = {} bytes\n", .{@sizeOf(*u8)});     // 8 em 64-bit

    // Todos têm o mesmo tamanho: usize == tamanho de ponteiro
}

usize vs isize

Use usize para índices e tamanhos (que nunca são negativos). Use isize quando precisar representar deslocamentos que podem ser negativos.

Armadilhas Comuns

• Misturar tipos inteiros: Usar u32 ou i32 como índice exige conversão explícita com @intCast. Zig não faz conversão implícita.
• Overflow em 32 bits: Código que funciona em 64 bits pode ter overflow em 32 bits se os valores excederem 4 GB. Teste em ambas as arquiteturas.
• Subtração de usize: Como usize é unsigned, subtrair um valor maior do menor causa panic em modo safe. Use std.math.sub para subtração segura.
• Confundir com u64: usize nem sempre é 64 bits. Em sistemas de 32 bits, é u32. Usar u64 onde usize é esperado requer conversão.

Termos Relacionados

• Slice — Referência a sequência contígua com .len do tipo usize
• Pointer Types — Tipos de ponteiro em Zig
• comptime_int — Inteiro de precisão arbitrária em comptime
• Type Coercion — Regras de conversão de tipos

Tutoriais Relacionados

• Sistema de Tipos do Zig
• Strings e Arrays em Zig
• Introdução ao Zig