---
title: "Comptime em Zig — O que é e Como Usar"
url: "https://ziglang.com.br/glossario/comptime-em-zig-o-que-%C3%A9-e-como-usar/"
markdown_url: "https://ziglang.com.br/glossario/comptime-em-zig-o-que-%C3%A9-e-como-usar.MD"
description: "Entenda comptime em Zig: execução em tempo de compilação que permite metaprogramação, genéricos e otimizações avançadas. Guia completo em pt-BR."
date: "2026-02-21"
author: "Zig Brasil"
---

# Comptime em Zig — O que é e Como Usar

Entenda comptime em Zig: execução em tempo de compilação que permite metaprogramação, genéricos e otimizações avançadas. Guia completo em pt-BR.


# Comptime em Zig — O que é e Como Usar

## Definição

**Comptime** (abreviação de *compile time*, tempo de compilação) é um dos recursos mais poderosos e distintivos da linguagem Zig. Ele permite que código seja **executado durante a compilação**, não em tempo de execução. Com `comptime`, você pode avaliar expressões, gerar tipos, desenrolar loops e criar funções genéricas — tudo antes do programa rodar.

Diferentemente de macros em C/C++ ou templates em C++, `comptime` em Zig usa a **mesma sintaxe** da linguagem normal. Não existe uma "linguagem separada" para metaprogramação.

## Por que Comptime Importa

1. **Genéricos sem custo**: Funções genéricas são resolvidas em tempo de compilação, gerando código especializado.
2. **Eliminação de código morto**: Condições avaliadas em comptime eliminam branches desnecessários do binário final.
3. **Validação antecipada**: Erros de lógica podem ser capturados na compilação, não em produção.
4. **Zero overhead**: Tudo que é resolvido em comptime não tem custo em runtime.

## Exemplo Prático

### Função Genérica com comptime

```zig
const std = @import("std");

fn maximo(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

pub fn main() void {
    const resultado_int = maximo(u32, 10, 20);
    const resultado_float = maximo(f64, 3.14, 2.71);

    std.debug.print("Max int: {}\n", .{resultado_int});
    std.debug.print("Max float: {d}\n", .{resultado_float});
}
```

O parâmetro `comptime T: type` obriga o compilador a resolver `T` durante a compilação. Isso gera duas versões especializadas da função — uma para `u32` e outra para `f64`.

### Bloco comptime

```zig
const std = @import("std");

const tabela = blk: {
    var resultado: [10]u32 = undefined;
    for (0..10) |i| {
        resultado[i] = i * i;
    }
    break :blk resultado;
};

pub fn main() void {
    // tabela já contém [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
    // calculado em tempo de compilação!
    std.debug.print("5² = {}\n", .{tabela[5]});
}
```

### Condicional em Comptime

```zig
const builtin = @import("builtin");

const separador = if (builtin.os.tag == .windows) '\\' else '/';
```

Aqui, o compilador avalia a condição durante a compilação e elimina completamente o branch não utilizado.

## Como Funciona

Quando o compilador Zig encontra `comptime`:

1. Ele executa o código durante a fase de compilação.
2. Variáveis `comptime` devem ser resolvidas sem depender de valores de runtime.
3. O resultado é "embutido" no binário como se fosse uma constante literal.
4. Funções chamadas em contexto comptime não podem ter efeitos colaterais de runtime (I/O, alocação de heap, etc.).

## Quando Usar comptime

- **Funções genéricas**: Sempre que uma função precisa aceitar tipos diferentes, use `comptime T: type` ou `anytype`.
- **Tabelas de lookup**: Calcule tabelas de valores conhecidos em comptime para evitar computação em runtime.
- **Configuração condicional por plataforma**: Use `comptime` junto com `builtin` para adaptar o código ao sistema operacional ou arquitetura.
- **Validação de invariantes**: Use `@compileError` para detectar usos inválidos durante a compilação.
- **DSLs e código gerado**: Gere structs, enums e funções dinamicamente com base em parâmetros comptime.

## Comparação com Outras Linguagens

| Recurso | Zig comptime | C macros | C++ templates | Rust const generics |
|---------|-------------|----------|---------------|-------------------|
| Sintaxe | Mesma da linguagem | Pré-processador | Sintaxe própria | Sintaxe adicional |
| Debugabilidade | Boa | Ruim | Mediana | Boa |
| Mensagens de erro | Claras | Confusas | Complexas | Claras |
| Reflexão de tipos | Sim (`@typeInfo`) | Não | Parcial | Limitada |
| Loops em comptime | Sim | Não | Sim (recursão) | Limitado |

Zig `comptime` é considerado por muitos como a abordagem mais elegante: você usa a mesma linguagem para código de compilação e de runtime, sem aprender uma sintaxe separada.

## Armadilhas Comuns

- **Tentar usar valores de runtime em contexto comptime**: Um parâmetro `comptime` não pode receber um valor que só é conhecido em tempo de execução. O compilador emitirá um erro claro.
- **Loops infinitos em comptime**: O compilador tem um limite de avaliação. Loops muito grandes em comptime resultam em erro de compilação.
- **Confundir `const` com `comptime`**: `const` apenas impede reatribuição; `comptime` garante avaliação em tempo de compilação.
- **Efeitos colaterais**: Chamar funções que fazem I/O em contexto comptime causará erro.

## Termos Relacionados

- [comptime_int](/glossario/comptime-int/) — Tipo inteiro de precisão arbitrária em comptime
- [comptime_float](/glossario/comptime-float/) — Tipo float de alta precisão em comptime
- [anytype](/glossario/anytype/) — Parâmetro de tipo inferido
- [Inline](/glossario/inline/) — Expansão inline de funções e loops

## Tutoriais Relacionados

- [Comptime em Zig — Guia Completo](/tutoriais/comptime-em-zig/)
- [Zig Comptime e Reflection](/tutoriais/zig-comptime-reflection/)
- [Introdução ao Zig](/tutoriais/introducao-ao-zig/)