---
title: "Cheatsheet: Tipos de Dados em Zig"
url: "https://ziglang.com.br/cheatsheets/cheatsheet-tipos-de-dados-em-zig/"
markdown_url: "https://ziglang.com.br/cheatsheets/cheatsheet-tipos-de-dados-em-zig.MD"
description: "Referência rápida de todos os tipos de dados em Zig: inteiros, floats, booleanos, arrays, ponteiros, optionals, structs e tipos compostos."
date: "2026-02-21"
author: "Zig Brasil"
---

# Cheatsheet: Tipos de Dados em Zig

Referência rápida de todos os tipos de dados em Zig: inteiros, floats, booleanos, arrays, ponteiros, optionals, structs e tipos compostos.


# Cheatsheet: Tipos de Dados em Zig

Referência completa de todos os tipos disponíveis na linguagem Zig, com exemplos práticos e tabelas de consulta rápida.

## Tipos Inteiros

### Inteiros com Sinal

| Tipo | Bits | Mínimo | Máximo |
|------|------|--------|--------|
| `i8` | 8 | -128 | 127 |
| `i16` | 16 | -32.768 | 32.767 |
| `i32` | 32 | -2.147.483.648 | 2.147.483.647 |
| `i64` | 64 | -9.223.372.036.854.775.808 | 9.223.372.036.854.775.807 |
| `i128` | 128 | -(2^127) | 2^127 - 1 |
| `isize` | arch | Depende da arquitetura | Depende da arquitetura |

### Inteiros sem Sinal

| Tipo | Bits | Mínimo | Máximo |
|------|------|--------|--------|
| `u8` | 8 | 0 | 255 |
| `u16` | 16 | 0 | 65.535 |
| `u32` | 32 | 0 | 4.294.967.295 |
| `u64` | 64 | 0 | 18.446.744.073.709.551.615 |
| `u128` | 128 | 0 | 2^128 - 1 |
| `usize` | arch | 0 | Depende da arquitetura |

### Inteiros de Tamanho Arbitrário

```zig
// Zig suporta inteiros de qualquer tamanho de 1 a 65535 bits
const meu_u3: u3 = 7;        // 3 bits: 0 a 7
const meu_i5: i5 = -16;      // 5 bits: -16 a 15
const meu_u12: u12 = 4095;   // 12 bits: 0 a 4095
const meu_u1: u1 = 1;        // 1 bit: 0 ou 1
```

## Tipos de Ponto Flutuante

| Tipo | Bits | Precisão | Equivalente C |
|------|------|----------|---------------|
| `f16` | 16 | ~3 dígitos | `_Float16` |
| `f32` | 32 | ~7 dígitos | `float` |
| `f64` | 64 | ~15 dígitos | `double` |
| `f80` | 80 | ~18 dígitos | `long double` (x86) |
| `f128` | 128 | ~33 dígitos | `__float128` |

```zig
const pi: f64 = 3.14159265358979;
const euler: f32 = 2.71828;

// Valores especiais
const inf = std.math.inf(f64);        // infinito
const neg_inf = -std.math.inf(f64);   // infinito negativo
const nan = std.math.nan(f64);        // NaN

// Verificações
const eh_nan = std.math.isNan(valor);
const eh_inf = std.math.isInf(valor);
```

## Tipo Booleano

```zig
const verdadeiro: bool = true;
const falso: bool = false;

// Operações lógicas
const resultado = verdadeiro and falso;  // false
const resultado2 = verdadeiro or falso;  // true
const resultado3 = !verdadeiro;          // false

// Conversão para inteiro
const como_int: u1 = @intFromBool(verdadeiro);  // 1
const como_bool: bool = @as(bool, @as(u1, 1));  // true
```

## Tipo Void

```zig
// void ocupa 0 bytes
const v: void = {};

// Usado como retorno de funções sem resultado
fn fazAlgo() void {
    // sem retorno
}

// Usado em tipos genéricos para "não ter valor"
const MapaSemValor = std.AutoHashMap([]const u8, void);
```

## Arrays

```zig
// Array de tamanho fixo
const numeros: [5]i32 = .{ 1, 2, 3, 4, 5 };

// Com tamanho inferido
const letras = [_]u8{ 'a', 'b', 'c' };

// Array com valor padrão
const zeros: [100]u8 = .{0} ** 100;
const padrao = [_]i32{-1} ** 10;  // [-1, -1, ..., -1]

// Array multidimensional
const matrix: [3][3]f32 = .{
    .{ 1.0, 0.0, 0.0 },
    .{ 0.0, 1.0, 0.0 },
    .{ 0.0, 0.0, 1.0 },
};

// Acesso
const primeiro = numeros[0];  // 1
const tamanho = numeros.len;  // 5

// Array com sentinela
const str: [5:0]u8 = .{ 'h', 'e', 'l', 'l', 'o' };
// str[5] é 0 (o sentinela)
```

## Slices

```zig
const array = [_]i32{ 1, 2, 3, 4, 5 };

// Criar slice a partir de array
const slice: []const i32 = array[1..4];  // {2, 3, 4}
const slice_ate_fim: []const i32 = array[2..];  // {3, 4, 5}

// Slice mutável
var mut_array = [_]i32{ 1, 2, 3 };
var mut_slice: []i32 = &mut_array;
mut_slice[0] = 10;

// Propriedades
const ptr = slice.ptr;  // ponteiro para o primeiro elemento
const len = slice.len;  // comprimento
```

## Optionals

```zig
// Tipo optional: ?T pode ser null ou T
var talvez: ?i32 = null;
talvez = 42;

// Desempacotar
if (talvez) |valor| {
    // valor é i32
    std.debug.print("{}\n", .{valor});
} else {
    // é null
}

// orelse — fornecer valor padrão
const seguro = talvez orelse 0;

// .? — forçar desempacotamento (panic se null)
const forcado = talvez.?;

// Optional de ponteiro
var ptr: ?*i32 = null;
```

## Error Sets e Error Unions

```zig
// Definir conjunto de erros
const MeuErro = error{
    ArquivoNaoEncontrado,
    PermissaoNegada,
    Timeout,
};

// Error union: !T pode ser erro ou T
fn dividir(a: f64, b: f64) !f64 {
    if (b == 0.0) return error.DivisaoPorZero;
    return a / b;
}

// Capturar erros
const resultado = dividir(10, 0) catch |err| {
    std.debug.print("Erro: {}\n", .{err});
    return;
};

// try — propagar erro
const valor = try dividir(10, 2);
```

## Ponteiros

```zig
// Ponteiro simples
var x: i32 = 42;
const ptr: *i32 = &x;
ptr.* = 100;  // dereferenciar e atribuir

// Ponteiro constante
const cptr: *const i32 = &x;
// cptr.* = 50;  // ERRO: não pode modificar

// Ponteiro para muitos elementos
const array = [_]i32{ 1, 2, 3, 4, 5 };
const mptr: [*]const i32 = &array;

// Ponteiro optional
var optr: ?*i32 = null;
optr = &x;

// Ponteiro com alinhamento
const aptr: *align(16) i32 = @alignCast(&x);
```

## Tipos Comptime

```zig
// comptime_int — inteiro de precisão arbitrária (só existe em comptime)
const big = 100000000000000000000;  // comptime_int

// comptime_float — float de precisão estendida
const precise = 3.14159265358979323846;  // comptime_float

// type — o tipo de um tipo (só existe em comptime)
const T: type = i32;
var valor: T = 42;

// noreturn — função que nunca retorna
fn panico() noreturn {
    @panic("erro fatal");
}
```

## Enums

```zig
const Cor = enum {
    vermelho,
    verde,
    azul,
};

const cor: Cor = .verde;

// Enum com tipo inteiro
const Status = enum(u8) {
    ativo = 1,
    inativo = 0,
    pendente = 2,
};

// Converter para inteiro
const valor = @intFromEnum(Status.ativo);  // 1
const status = @enumFromInt(1);  // Status.ativo
```

## Structs

```zig
const Ponto = struct {
    x: f64,
    y: f64,
    z: f64 = 0.0,  // valor padrão

    // Método
    pub fn distancia(self: Ponto, outro: Ponto) f64 {
        const dx = self.x - outro.x;
        const dy = self.y - outro.y;
        return @sqrt(dx * dx + dy * dy);
    }
};

const p = Ponto{ .x = 1.0, .y = 2.0 };
const d = p.distancia(Ponto{ .x = 4.0, .y = 6.0 });

// Struct anônima (tuple)
const tupla: struct { i32, []const u8 } = .{ 42, "olá" };
```

## Unions

```zig
// Tagged union
const Valor = union(enum) {
    inteiro: i64,
    float: f64,
    texto: []const u8,
    nenhum: void,
};

const v = Valor{ .inteiro = 42 };

switch (v) {
    .inteiro => |i| std.debug.print("Int: {}\n", .{i}),
    .float => |f| std.debug.print("Float: {d}\n", .{f}),
    .texto => |t| std.debug.print("Texto: {s}\n", .{t}),
    .nenhum => std.debug.print("Nenhum\n", .{}),
}
```

## Tabela de Conversões Comuns

| De | Para | Como |
|----|------|------|
| `i32` → `i64` | inteiro menor → maior | Implícito: `const y: i64 = x;` |
| `i64` → `i32` | inteiro maior → menor | `@intCast(x)` |
| `i32` → `f64` | inteiro → float | `@floatFromInt(x)` |
| `f64` → `i32` | float → inteiro | `@intFromFloat(x)` |
| `bool` → `u1` | bool → inteiro | `@intFromBool(x)` |
| `enum` → `int` | enum → inteiro | `@intFromEnum(x)` |
| `int` → `enum` | inteiro → enum | `@enumFromInt(x)` |
| `*T` → `*U` | ponteiro → ponteiro | `@ptrCast(x)` |
| `usize` → `*T` | inteiro → ponteiro | `@ptrFromInt(x)` |
| `*T` → `usize` | ponteiro → inteiro | `@intFromPtr(x)` |

## Veja Também

- [Sintaxe Básica](/cheatsheets/sintaxe-basica/) — Fundamentos da linguagem
- [Ponteiros](/cheatsheets/ponteiros/) — Guia completo de ponteiros
- [Structs](/cheatsheets/structs/) — Detalhes sobre structs
- [Enums e Unions](/cheatsheets/enums-unions/) — Enumerações e unions em detalhes
- [FAQ sobre Memória](/faq/faq-memoria/) — Perguntas sobre gerenciamento de memória