Sandbox C

Sandbox C online — compile e execute código C11 via GCC 10.2 no navegador. Flags personalizados, suporte stdin, 6 exemplos iniciais. 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 10 segundos de runtime, então código não confiável não pode prejudicar nada. 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. Argumentos personalizados do compilador (-Wall, -Wextra, -O0..-O3, -std=c89..c11, -lm, -lpthread) permitem experimentar com níveis de otimização, padrões de linguagem 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`

Sandbox C — Sandbox C online — compile e execute código C11 via GCC 10.2 no navegador. Flags personalizados, suporte stdin, 6 exempl — **Sandbox C**

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`

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.

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.