Hoja de Trucos de C
Última actualización
Hola Mundo y estructura del programa
Cada programa en C empieza en main y devuelve un int.
| Elemento | Código |
|---|---|
| Incluir una cabecera | #include <stdio.h> |
| Punto de entrada | int main(void) { ... } |
| Con argumentos de línea de comandos | int main(int argc, char *argv[]) { ... } |
| Imprimir una línea | printf("Hello, World!\n"); |
| Devolver éxito | return 0; |
| Comentario de una línea | // comment |
| Comentario de bloque | /* comment */ |
Tipos de datos
Los tamaños dependen de la plataforma; los mínimos de abajo están garantizados por el estándar.
| Tipo | Descripción |
|---|---|
int | Entero, al menos 16 bits (normalmente 32) |
unsigned int | Entero no negativo |
long / long long | Enteros más anchos (al menos 32 / 64 bits) |
float / double | Punto flotante de precisión simple / doble |
char | Un solo byte, también se usa para caracteres |
_Bool (bool vía <stdbool.h>) | true o false |
size_t | Tipo sin signo para tamaños e índices |
void | Sin tipo: se usa para funciones y punteros genéricos |
Especificadores de formato de printf y scanf
Marcadores de posición que coinciden con el tipo de cada argumento.
| Especificador | Coincide con |
|---|---|
%d / %i | int con signo |
%u | int sin signo |
%ld / %lld | long / long long |
%f | double (y float en printf) |
%.2f | double con 2 decimales |
%c | Un solo char |
%s | Cadena (char *) |
%p | Dirección de un puntero |
%x | int sin signo en hexadecimal |
%zu | size_t |
Operadores
| Operador | Significado |
|---|---|
+ - * / % | Aritmética (% es el resto entero) |
== != | Igual / distinto |
< > <= >= | Comparación |
&& || ! | And / or / not lógicos |
& | ^ ~ << >> | And, or, xor, not y desplazamientos a nivel de bits |
++ -- | Incremento / decremento |
+= -= *= /= | Asignación compuesta |
cond ? a : b | Condicional ternario |
sizeof(x) | Tamaño de un tipo o variable en bytes |
Control de flujo
| Sentencia | Sintaxis |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Else if | else if (x == 0) { ... } |
| Switch | switch (n) { case 1: ...; break; default: ...; } |
| Bucle while | while (i < n) { ... } |
| Bucle do-while | do { ... } while (i < n); |
| Bucle for | for (int i = 0; i < n; i++) { ... } |
| Break / continue | break; sale de un bucle, continue; salta a la siguiente iteración |
| Goto (poco común) | goto label; ... label: |
Funciones
Declara antes de usar o añade un prototipo al inicio del archivo.
| Operación | Sintaxis |
|---|---|
| Definir una función | int add(int a, int b) { return a + b; } |
| Prototipo (declaración) | int add(int a, int b); |
| Sin valor de retorno | void greet(void) { ... } |
| Sin parámetros | int rand_seed(void) { ... } |
| Paso por puntero (modificar) | void inc(int *p) { (*p)++; } |
| Pasar un array | int sum(int arr[], int n) { ... } |
| Estática (local al archivo) | static int helper(void) { ... } |
Punteros y memoria
Un puntero almacena una dirección. La memoria del heap debe liberarse manualmente.
| Operación | Sintaxis |
|---|---|
| Declarar un puntero | int *p; |
| Dirección de | p = &x; |
| Desreferenciar (leer/escribir) | int y = *p; / *p = 10; |
| Puntero nulo | int *p = NULL; |
| Reservar en el heap | int *a = malloc(n * sizeof(int)); |
| Reservar + poner a cero | int *a = calloc(n, sizeof(int)); |
| Redimensionar una reserva | a = realloc(a, newSize); |
| Liberar memoria del heap | free(a); |
| Aritmética de punteros | *(a + i) es lo mismo que a[i] |
Arrays y cadenas
Las cadenas en C son arrays de char terminados en \0.
| Operación | Sintaxis |
|---|---|
| Declarar un array | int nums[5]; |
| Inicializar un array | int nums[] = {1, 2, 3}; |
| Acceder a un elemento | nums[0] = 10; |
| Longitud del array (arrays en pila) | sizeof(nums) / sizeof(nums[0]) |
| Literal de cadena | char s[] = "hello"; |
| Longitud de la cadena | strlen(s) (excluye \0) |
| Copiar una cadena | strcpy(dst, src); |
| Comparar cadenas | strcmp(a, b) == 0 significa iguales |
| Concatenar cadenas | strcat(dst, src); |
Structs y stdlib común
| Operación | Sintaxis |
|---|---|
| Definir un struct | struct Point { int x; int y; }; |
| Declarar y acceder | struct Point p; p.x = 1; |
| Acceder vía puntero | p->x = 1; (igual que (*p).x) |
| Alias de tipo | typedef struct Point Point; |
| Leer entrada | scanf("%d", &n); |
| Convertir cadena a int | int n = atoi("42"); |
| Valor absoluto / potencia | abs(x) (int), pow(x, y) de <math.h> |
| Ordenar un array | qsort(arr, n, sizeof(int), cmp); |
La sintaxis, los especificadores de formato y los patrones de punteros de C que más usas, en una sola página. Esta hoja de trucos de C es una referencia rápida para escribir C: los tipos de datos, los especificadores de printf/scanf, los operadores, el control de flujo y las operaciones de punteros y memoria que dan problemas.
Todo lo que hay aquí es C estándar (C99/C11) y se compila con gcc o clang. Copia lo que necesites o prueba cualquier fragmento en vivo en el playground de C, sin instalar ningún compilador.
Preguntas frecuentes sobre la hoja de trucos de C
¿Esta hoja de trucos de C es gratis?
Sí. Esta hoja de trucos de C es completamente gratuita, sin necesidad de registrarse. Guárdala en favoritos y vuelve cuando necesites consultar un tipo, un especificador de formato o una operación de punteros.
¿Cuál es la diferencia entre la pila y el heap en C?
La memoria de la pila almacena las variables locales y se libera automáticamente cuando una función retorna: es rápida, pero limitada en tamaño. La memoria del heap se reserva explícitamente con
malloc o calloc, vive hasta que llamas a free y se usa cuando necesitas memoria que sobreviva a la función actual o cuyo tamaño solo se conoce en tiempo de ejecución. Olvidar hacer free de la memoria del heap provoca una fuga de memoria.¿Por qué scanf necesita un ampersand (&) pero printf no?
scanf escribe el valor de vuelta en tu variable, así que necesita la dirección de la variable, que es lo que le da &x. printf solo lee el valor, así que le pasas el valor en sí. La excepción son las cadenas: un array de char ya degenera en un puntero, así que pasas scanf("%s", name) sin el &.¿Puedo practicar C en línea?
Sí. Abre el playground de C para compilar y ejecutar cualquier fragmento de esta hoja de trucos en tu navegador, sin instalar ningún compilador. Cuando quieras estructura, el curso interactivo y gratuito de C de Coddy te lleva paso a paso desde las variables y los bucles hasta los punteros y la gestión de memoria.
¿Esta hoja de trucos es buena para principiantes?
Sí. Está organizada desde los componentes básicos más comunes (tipos, printf, control de flujo) hasta los avanzados (punteros, memoria, structs), de modo que puedes usar las secciones de arriba desde el primer día e ir avanzando hacia el resto.
Recursos relacionados
Más hojas de referencia
