Sandbox C

Sandbox C online — compile y ejecute C con GCC 10.2 en su navegador. Elija C89/C99/C11/C17, active -Werror, añada flags (-Wall -O2 -lm) y stdin. Sin instalación.

¿Tienes comentarios? Reporta errores, sugiere funciones o comparte tus ideas — leemos todos

Sandbox C - Ejecutar Código C Online Gratis

C es la lingua franca de la programación de sistemas — el kernel de Linux, los runtimes de Python y Node.js, todo firmware embebido, todo motor de base de datos, toda cartera de criptomonedas, y aproximadamente la mitad de los intérpretes de lenguajes 'de alto nivel' están escritos en C. Sin embargo, configurar una cadena de herramientas C local (instalar GCC/Clang, configurar PATH, aprender Makefile) es el primer muro contra el que choca todo programador nuevo. Este sandbox elimina ese muro: pegue un fragmento, presione Ejecutar, y su código compila y se ejecuta contra GCC 10.2.0 con soporte completo del estándar C11 en menos de un segundo. La ejecución ocurre en servidor vía la API Piston open source (engineer-man/piston en GitHub) en un contenedor Docker aislado sin acceso a red y con límite estricto de 3 segundos de ejecución (así que código no confiable no puede dañar nada, y los benchmarks pesados pueden cortarse). Obtiene la stdout del programa, advertencias/errores de compilación con números de línea, tiempo de ejecución y código de salida. Un selector de Estándar C (C89/ANSI, C99, C11, C17) y un interruptor -Werror de un clic le permiten verificar portabilidad y conformidad, mientras que los argumentos personalizados del compilador (-Wall, -Wextra, -O0..-O3, -lm, -lpthread) le permiten experimentar con niveles de optimización y enlace de bibliotecas. El campo stdin alimenta entrada estándar a programas basados en scanf/getchar/fgets sin reescribirlos. Seis ejemplos iniciales categorizados — Hello World, bucle for, definición de función, iteración de array, dereferenciación de punteros, uso de struct — cubren la sintaxis que vería en la semana uno de cualquier curso de C.

¿Qué es Sandbox C?

Sandbox C es un compilador C online que le permite ejecutar código C directamente en su navegador sin instalar nada. Usando la API Piston y compilador GCC, proporciona:

- Compilación y ejecución de código instantánea
- Soporte para librería estándar de C
- Flags y argumentos de compilador personalizados
- Soporte de entrada estándar (stdin)
- Mensajes de error e información de depuración
- Ejemplos de código para aprender

Perfecto para estudiantes, desarrolladores y cualquiera aprendiendo programación C.

¿Cómo uso este Sandbox C?

Usar el Sandbox C es simple:

1. Escriba o pegue su código C en el editor
2. (Opcional) Agregue argumentos de compilador como -Wall -O2
3. (Opcional) Proporcione entrada stdin si su programa la necesita
4. Haga clic en 'Ejecutar Código' para compilar y ejecutar
5. Vea la salida o errores de compilación
6. Pruebe códigos de ejemplo para aprender conceptos básicos de C

También puede descargar su código como archivo .c para uso posterior.

¿Qué características de C son compatibles?

El sandbox admite características completas del lenguaje de programación C:

- Todas las características del estándar C11
- Librería estándar (stdio.h, stdlib.h, string.h, math.h, etc.)
- Asignación dinámica de memoria (malloc, calloc, free)
- Operaciones de E/S de archivos
- Punteros y aritmética de punteros
- Estructuras y uniones
- Arrays y strings
- Punteros a funciones
- Directivas de preprocesador

Compilador: GCC 10.2.0 con soporte de estándar C11.

¿Puedo usar flags de compilador?

¡Sí! Puede agregar argumentos de compilador personalizados en el campo 'Argumentos del Compilador'. Ejemplos comunes:

- `-Wall` - Habilitar todas las advertencias
- `-Wextra` - Habilitar advertencias extra
- `-O2` - Nivel de optimización 2
- `-std=c11` - Usar estándar C11
- `-lm` - Enlazar librería matemática
- `-g` - Incluir símbolos de depuración

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

¿Cómo funciona la entrada stdin?

Si su programa usa scanf(), gets(), fgets() u otras funciones de entrada, puede proporcionar la entrada en el campo 'Entrada Estándar'.

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

En el campo stdin, ingrese: `42`

El programa leerá este valor y producirá: `You entered: 42`

Sandbox C — Sandbox C online — compile y ejecute C con GCC 10.2 en su navegador. Elija C89/C99/C11/C17, active -Werror, añada flags — **Sandbox C**

¿Por qué mi programa con malloc/free parece tener una fuga de memoria?

Probablemente no la tiene — pero el sandbox no puede confirmárselo porque Valgrind no está disponible en el servidor. La ilusión de fuga en este entorno suele venir de tres cosas. (1) Asignó memoria y olvidó free() antes de salir — estrictamente no es una fuga, ya que el SO recupera toda la memoria al terminar el proceso, pero sigue siendo un bug en código de larga duración. (2) Confunde 'memoria heap usada' con 'memoria fugada': asignar un array de un millón de int usa ~4 MB legítimamente. (3) Su free() está en una ruta inalcanzable — por ejemplo tras un return temprano o dentro de un if que no se ejecutó. Para verificarlo offline, instale GCC más Valgrind localmente y ejecute 'valgrind --leak-check=full ./suprograma' — Valgrind reporta cada malloc sin free correspondiente con la línea exacta de la asignación. Los compiladores modernos también soportan AddressSanitizer ('gcc -fsanitize=address') que detecta fugas en runtime con mucho menos overhead que Valgrind.

¿Por qué mi código falla con 'Segmentation fault'?

Segfault significa que su programa intentó acceder a una dirección de memoria que no posee. Las cinco causas más comunes en C principiante:

(1) Desreferenciar un puntero NULL: int *p = NULL; *p = 5; — crash. Siempre verifique punteros antes de desreferenciarlos.

(2) Desreferenciar un puntero NO INICIALIZADO: int *p; *p = 5; — p contiene basura aleatoria de la pila que casi seguro no es una dirección válida.

(3) Buffer overflow: char buf[10]; strcpy(buf, "esta cadena es demasiado larga"); — escribe más allá del final del array en memoria de pila adyacente.

(4) Use-after-free: int *p = malloc(4); free(p); *p = 5; — p aún tiene la dirección antigua pero la memoria ya no es suya.

(5) Stack overflow por recursión infinita: int f(int n) { return f(n+1); } — main llama a f, f llama a f, eventualmente la pila alcanza su límite.

El sandbox imprime 'Segmentation fault (core dumped)' y código de salida 139 (128+SIGSEGV) cuando ocurre. Compile con -g y use un depurador local (gdb) o AddressSanitizer para identificar la línea exacta.

¿Qué estándar de C debo elegir (C89, C99, C11, C17)?

Use el menú 'Estándar C' para compilar contra una versión específica del lenguaje — establece -std= por usted. Elija según el objetivo, no por 'lo más nuevo es mejor':

- C89 (ANSI C): el más portable. Muchos toolchains embebidos y bases de código heredadas lo requieren. C89 prohíbe los comentarios // de línea, declaraciones después de sentencias y variables con alcance de bucle for (for (int i...) es un error). Seleccionar C89 es la forma más rápida de comprobar si su código es realmente portable.

- C99: añade comentarios //, declaraciones mezcladas, inicializadores designados, arrays de longitud variable, long long, stdint.h y bool vía stdbool.h. Una base sensata para código moderno.

- C11: añade _Static_assert, structs/uniones anónimas, _Generic y los opcionales <threads.h>/<stdatomic.h> para concurrencia portable. Predeterminado aquí.

- C17 (alias C18): sin funciones nuevas — es C11 con correcciones de defectos. Elíjalo cuando quiera la semántica de C11 con las últimas correcciones de errores.

Consejo: active -Werror y compile bajo C89 para exponer cada construcción no portable como un error fatal.

¿Qué cambia entre -O0 y -O3, y por qué la salida puede diferir?

Las flags -O controlan la optimización, que puede cambiar drásticamente el código generado (y a veces revelar bugs):

- -O0 (predeterminado si no establece nada): sin optimización. Compila más rápido, más fácil de depurar, las variables permanecen en memoria. Mejor durante el desarrollo.

- -O1 / -O2: progresivamente más agresivas — inlining, eliminación de código muerto, optimizaciones de bucle, asignación de registros. -O2 es el ajuste habitual de release.

- -O3: añade inlining agresivo y vectorización. Binarios más grandes; no siempre más rápido.

- -Os / -Ofast: optimizan para tamaño / para velocidad pura (relajando las matemáticas IEEE). Evite -Ofast salvo que entienda los compromisos de coma flotante.

Por qué los resultados pueden diferir entre niveles: si su programa tiene COMPORTAMIENTO INDEFINIDO (desbordamiento con signo, lectura de memoria no inicializada, acceso fuera de límites, violaciones de strict-aliasing), el optimizador puede asumir que nunca ocurre y eliminar o reordenar código en consecuencia. El código que 'funciona' en -O0 pero falla en -O2 casi siempre oculta comportamiento indefinido — compile con -Wall -Wextra y pruebe -fsanitize=undefined localmente para detectarlo.

¿Mi código está seguro y privado?

La privacidad de su código depende del método de ejecución:

- El código se envía a la API Piston (emkc.org) para compilación
- Piston es de código abierto y mantenido por la comunidad
- El código no es almacenado ni registrado por Piston
- La ejecución ocurre en contenedores aislados
- Sin acceso a su sistema local

Para máxima privacidad, puede auto-hospedar Piston usando Docker.