Sandbox C

Sandbox C online — compile e execute C com GCC 10.2 no navegador. Escolha C89/C99/C11/C17, ative -Werror, adicione flags (-Wall -O2 -lm) e stdin. Sem instalação.

Tem feedback? Reporte bugs, sugira recursos ou compartilhe suas ideias — lemos todos

Sandbox C - Execute Código C Online Gratuitamente

C é a língua franca da programação de sistemas — o kernel Linux, os runtimes de Python e Node.js, todo firmware embarcado, todo mecanismo de banco de dados, toda carteira de criptomoeda, e aproximadamente metade dos interpretadores de linguagem de 'alto nível' são escritos em C. Ainda assim, configurar um toolchain C local (instalar GCC/Clang, configurar PATH, aprender Makefile básico) é a primeira parede que todo programador novo encontra. Este sandbox remove essa parede: cole um snippet, pressione Executar, e seu código compila e executa contra GCC 10.2.0 com suporte completo ao padrão C11 em menos de um segundo. A execução acontece no servidor via a API Piston open-source (engineer-man/piston no GitHub) em um container Docker isolado sem acesso à rede e com limite rígido de 3 segundos de runtime (então código não confiável não pode prejudicar nada, e benchmarks pesados podem ser interrompidos). Você obtém o stdout do programa, quaisquer avisos/erros de compilação com números de linha, tempo de execução e código de saída. Um seletor de Padrão C (C89/ANSI, C99, C11, C17) e um botão -Werror de um clique permitem verificar portabilidade e conformidade, enquanto argumentos personalizados do compilador (-Wall, -Wextra, -O0..-O3, -lm, -lpthread) permitem experimentar com níveis de otimização e linkagem de bibliotecas. O campo stdin alimenta entrada padrão para programas baseados em scanf/getchar/fgets sem reescrevê-los. Seis exemplos iniciais categorizados — Hello World, loop for, definição de função, iteração de array, dereferenciação de ponteiros, uso de struct — cobrem a sintaxe que você veria na primeira semana de qualquer curso de C.

O que é Sandbox C?

Sandbox C é um compilador C online que permite executar código C diretamente no seu navegador sem instalar nada. Usando a API Piston e compilador GCC, fornece:

- Compilação e execução instantânea de código
- Suporte para biblioteca padrão C
- Flags e argumentos personalizados do compilador
- Suporte a entrada padrão (stdin)
- Mensagens de erro e informações de depuração
- Exemplos de código para aprender

Perfeito para estudantes, desenvolvedores e qualquer pessoa aprendendo programação C.

Como usar este Sandbox C?

Usar o Sandbox C é simples:

1. Escreva ou cole seu código C no editor
2. (Opcional) Adicione argumentos do compilador como -Wall -O2
3. (Opcional) Forneça entrada stdin se seu programa precisar
4. Clique em 'Executar Código' para compilar e executar
5. Visualize a saída ou erros de compilação
6. Experimente códigos de exemplo para aprender básicos de C

Você também pode baixar seu código como arquivo .c para uso posterior.

Quais recursos de C são suportados?

O sandbox suporta todos os recursos da linguagem de programação C:

- Todos os recursos do padrão C11
- Biblioteca padrão (stdio.h, stdlib.h, string.h, math.h, etc.)
- Alocação dinâmica de memória (malloc, calloc, free)
- Operações de E/S de arquivo
- Ponteiros e aritmética de ponteiros
- Estruturas e uniões
- Arrays e strings
- Ponteiros de função
- Diretivas de pré-processador

Compilador: GCC 10.2.0 com suporte ao padrão C11.

Posso usar flags de compilador?

Sim! Você pode adicionar argumentos personalizados do compilador no campo 'Argumentos do Compilador'. Exemplos comuns:

- `-Wall` - Habilitar todos os avisos
- `-Wextra` - Habilitar avisos extras
- `-O2` - Nível de otimização 2
- `-std=c11` - Usar padrão C11
- `-lm` - Vincular biblioteca matemática
- `-g` - Incluir símbolos de depuração

Exemplo: `-Wall -Wextra -O2 -std=c11`

Como funciona a entrada stdin?

Se seu programa usa scanf(), gets(), fgets() ou outras funções de entrada, você pode fornecer a entrada no campo 'Entrada Padrão'.

Programa de exemplo:
```c
#include <stdio.h>
int main() {
int num;
scanf("%d", &num);
printf("Você digitou: %d\n", num);
return 0;
}
```

No campo stdin, digite: `42`

O programa lerá este valor e imprimirá: `Você digitou: 42`

Sandbox C — Sandbox C online — compile e execute C com GCC 10.2 no navegador. Escolha C89/C99/C11/C17, ative -Werror, adicione flags — **Sandbox C**

Por que meu programa com malloc/free parece vazar memória?

Provavelmente não vaza — mas o sandbox não pode confirmar com certeza porque o Valgrind não está disponível no servidor. A ilusão de vazamento de memória neste ambiente geralmente vem de uma de três coisas. (1) Você alocou memória e esqueceu free() antes do programa sair — estritamente falando isto não é um vazamento, já que o SO recupera toda a memória do processo ao sair, mas ainda é um bug que importaria em código de longa duração. (2) Você está confundindo 'memória heap usada' com 'memória vazada': alocar um array de um milhão de int usa ~4 MB legitimamente. (3) Seu free() está em um caminho de código inalcançável — por exemplo após um return antecipado ou dentro de um if que não disparou. Para checar isto offline, instale GCC mais Valgrind localmente e execute 'valgrind --leak-check=full ./seuprograma' — Valgrind reporta cada malloc sem free correspondente junto com a linha exata de origem da alocação. Compiladores modernos também suportam AddressSanitizer ('gcc -fsanitize=address') que pega vazamentos em runtime com overhead muito menor que Valgrind.

Por que meu código falha com 'Segmentation fault'?

Segfault significa que seu programa tentou acessar um endereço de memória que não possui. As cinco causas mais comuns em C iniciante:

(1) Dereferenciar um ponteiro NULL: int *p = NULL; *p = 5; — crash. Sempre cheque ponteiros antes de dereferenciar.

(2) Dereferenciar um ponteiro NÃO INICIALIZADO: int *p; *p = 5; — p contém lixo aleatório da stack que quase certamente não é um endereço válido.

(3) Buffer overflow: char buf[10]; strcpy(buf, "esta string é longa demais"); — escreve além do fim do array em memória de stack adjacente.

(4) Use-after-free: int *p = malloc(4); free(p); *p = 5; — p ainda tem o endereço antigo mas a memória não é mais sua.

(5) Stack overflow por recursão infinita: int f(int n) { return f(n+1); } — main chama f, f chama f, eventualmente a call stack atinge seu limite de tamanho.

O sandbox imprime 'Segmentation fault (core dumped)' e código de saída 139 (128+SIGSEGV) quando isto acontece. Compile com -g e use um debugger local (gdb) ou AddressSanitizer para apontar a linha exata.

Qual padrão de C devo escolher (C89, C99, C11, C17)?

Use o menu 'Padrão C' para compilar contra uma versão específica da linguagem — ele define o -std= para você. Escolha pelo alvo, não por 'o mais novo é o melhor':

- C89 (ANSI C): o mais portável. Muitos toolchains embarcados e bases de código legadas o exigem. C89 proíbe comentários // de linha, declarações após instruções e variáveis com escopo no laço for (for (int i...) é um erro). Selecionar C89 é a forma mais rápida de checar se seu código é realmente portável.

- C99: adiciona comentários //, declarações misturadas, inicializadores designados, arrays de comprimento variável, long long, stdint.h e bool via stdbool.h. Uma base sensata para código moderno.

- C11: adiciona _Static_assert, structs/uniões anônimas, _Generic e os opcionais <threads.h>/<stdatomic.h> para concorrência portável. Padrão aqui.

- C17 (também C18): sem recursos novos — é o C11 com correções de defeitos. Escolha-o quando quiser a semântica do C11 com as últimas correções de bugs.

Dica: ative -Werror e compile sob C89 para expor cada construção não portável como um erro fatal.

O que muda entre -O0 e -O3, e por que a saída pode diferir?

As flags -O controlam a otimização, que pode mudar drasticamente o código gerado (e às vezes revelar bugs):

- -O0 (padrão se você não definir nada): sem otimização. Compila mais rápido, mais fácil de depurar, as variáveis permanecem na memória. Melhor durante o desenvolvimento.

- -O1 / -O2: progressivamente mais agressivas — inlining, eliminação de código morto, otimizações de laço, alocação de registradores. -O2 é o ajuste usual de release.

- -O3: adiciona inlining agressivo e vetorização. Binários maiores; nem sempre mais rápido.

- -Os / -Ofast: otimizam para tamanho / para velocidade pura (relaxando a matemática IEEE). Evite -Ofast a menos que entenda os tradeoffs de ponto flutuante.

Por que os resultados podem diferir entre níveis: se seu programa tem COMPORTAMENTO INDEFINIDO (overflow com sinal, leitura de memória não inicializada, acesso fora dos limites, violações de strict-aliasing), o otimizador pode assumir que isso nunca acontece e deletar ou reordenar código conforme. Código que 'funciona' em -O0 mas quebra em -O2 quase sempre esconde comportamento indefinido — compile com -Wall -Wextra e teste -fsanitize=undefined localmente para detectá-lo.

Meu código está seguro e privado?

A privacidade do seu código depende do método de execução:

- Código é enviado para API Piston (emkc.org) para compilação
- Piston é código aberto e mantido pela comunidade
- Código não é armazenado ou registrado pelo Piston
- Execução acontece em contêineres isolados
- Sem acesso ao seu sistema local

Para máxima privacidade, você pode auto-hospedar Piston usando Docker.