Descripción general del lenguaje C

C (ANSI C99 / C11) — lenguaje de sistemas | tiempo de ejecución mínimo | memoria manual | control máximo

paradigma

Imperativo, procesal. Escritura estática con sistema de tipos débiles (conversiones implícitas, void*). Compilación mediante preprocesador → compilador → ensamblador → enlazador. Compilación de una sola pasada, basada en unidades de traducción.

Tipos

Categoría Tipos Tamaño (típico)
carbón char 1 byte
Firmado entero signed char short int long long long 1, 2, 4, 8, 8 bytes
entero sin firmar unsigned char unsigned short unsigned int unsigned long unsigned long long 1, 2, 4, 8, 8 bytes
flotador float double long double 4, 8, 8-16 bytes
Booleano (C99) _Bool / bool (a través de <stdbool.h>) 1 byte
vacío void 0 (incompleto)
puntero T* 8 bytes (64 bits)
matriz T[N] T[] N * tamaño de (T)
estructura struct Name { ... } Suma de campos + relleno
unión union Name { ... } Máximo de campos
enumeración enum Name { ... } tamaño de (int)
Puntero de función T (*)(args) 8 bytes

Modificadores de tipo

const volatile restrict (C99) inline (C99)

Especificadores de clase de almacenamiento

auto register static extern _Thread_local (C11)

Declaraciones

construir Sintaxis Notas
Función T name(params) { body }
Prototipo T name(params); Declaración sin cuerpo
variable T x = expr;
Múltiple T x, y, z;
constante const T x = expr;
constante de enumeración enum { VAL = expr };
definición de tipo typedef T Alias;
estructura struct Name { T field; };
unión union Name { T field; };
externo extern T name; Definido en otra TU
estática static T name; Vinculación interna

Controlar el flujo

construir Sintaxis Notas
si if (cond) { ... } else { ... } Declaración, no expresión
mientras while (cond) { ... }
hacer mientras do { ... } while (cond);
Para for (init; cond; incr) { ... }
Cambiar switch (expr) { case N: ... break; } Fallo por defecto
descanso break; Salir de loop/switch
Continuar continue; Saltar a la siguiente iteración
ir a goto label; Sólo dentro de la función
Regresar return expr;

Operadores (precedencia, de mayor a menor)

Prioridad Operadores Asociación
1 () [] . -> ++ -- (postfijo) Izquierda
2 ++ -- (prefijo) + - ! ~ * & sizeof _Alignof Derecha
3 (type) (elenco) Derecha
4 * / % Izquierda
5 + - Izquierda
6 << >> Izquierda
7 < > <= >= Izquierda
8 == != Izquierda
9 & Izquierda
10 ^ Izquierda
11 | Izquierda
12 && Izquierda
13 || Izquierda
14 ? : (ternario) Derecha
15 = += -= *= /= %= &= ^= |= <<= >>= Derecha
16 , (operador de coma) Izquierda

Preprocesador

Directiva Propósito
#include "file" / <file> Inclusión textual
#define MACRO body Macro tipo objeto
#define MACRO(args) body Macro similar a una función
#undef MACRO Quitar macro
#if expr / #ifdef MACRO / #ifndef MACRO Compilación condicional
#elif expr / #else / #endif Otras sucursales
#error "message" Error en tiempo de compilación
#pragma Definido por la implementación
#line N "file" control de línea
## (pegado de tokens) Concatenar tokens
# (stringificar) Convertir a cadena literal

Macros predefinidas (C99)

__LINE__ __FILE__ __DATE__ __TIME__ __STDC__ __STDC_VERSION__ __func__

Memoria

Operación Sintaxis encabezado
asignar malloc(n) <stdlib.h>
Asignación alineada (C11) aligned_alloc(a, n) <stdlib.h>
Calloc calloc(n, size) <stdlib.h>
Reasignar realloc(p, n) <stdlib.h>
Gratis free(p) <stdlib.h>
Copiar memcpy(dst, src, n) <string.h>
Mover (superposición segura) memmove(dst, src, n) <string.h>
conjunto memset(p, c, n) <string.h>
Comparar memcmp(a, b, n) <string.h>
pila alloca(n) (no estándar) <alloca.h>

Biblioteca estándar (seleccionada)

<stdio.h>

printf scanf fopen fclose fread fwrite fprintf sprintf fgets fputs feof ferror remove rename tmpfile

<stdlib.h>

atoi atof strtol strtod rand srand abs qsort bsearch system getenv exit abort atexit

<string.h>

strlen strcpy strncpy strcat strncat strcmp strncmp strchr strrchr strstr strtok memset memcpy memmove memcmp

<math.h>

sin cos tan asin acos atan atan2 sqrt pow exp log log10 fabs ceil floor fmod fma

<time.h>

time clock difftime mktime strftime localtime gmtime

<assert.h>

assert(expr)

<stdint.h> (C99)

int8_t int16_t int32_t int64_t uint8_t uint16_t uint32_t uint64_t intptr_t uintptr_t size_t

<stdbool.h> (C99)

bool true false

Compilación

paso Comando Salida
Preproceso cpp file.c > file.i fuente ampliada
compilar cc -S file.c Ensamblaje (file.s)
montar cc -c file.c Objeto (file.o)
Enlace cc file.o -o prog Ejecutable (prog)
Todo en uno cc file.c -o prog Ejecutable directo

Banderas comunes

-O0 -O1 -O2 -O3 -Os -g -Wall -Wextra -Wpedantic -std=c99 -std=c11 -DNAME=val -Ipath -Lpath -llib

Cadena de herramientas

GCC (GNU), Clang/LLVM, MSVC (Windows), TinyCC, CompCert

Duración del almacenamiento

Duración Asignación Toda la vida
Automático pila Alcance
estática segmento de datos Vida útil del programa
Hilo local (C11) TLS Vida útil del hilo
Asignado Montón (malloc/free) manuales

vinculación

palabra clave vinculación Visibilidad
(ninguno, alcance del archivo) Externo Programa completo
static (alcance del archivo) Interno Unidad de traducción actual
extern Externo Programa completo
static inline (C99) Interno TU actual (sin fuera de línea)

Comportamiento indefinido (errores seleccionados)

C99 frente a C11 frente a C17 frente a C23

Estándar Adiciones clave
C89/ANSI C Estándar original
C99 // comentarios, stdint.h, bool, restrict, inline, macros variadas, inicializadores designados, literales compuestos, for-declaraciones de alcance
C11 _Generic, _Static_assert, _Alignas, _Alignof, _Atomic, _Thread_local, anónimo structs/unions, noreturn, interfaces con límites verificados (Anexo K)
C17 Lanzamiento de corrección de errores (sin funciones nuevas)
C23 (borrador) typeof, nullptr, #embed, bool como palabra clave, static_assert sin _, constexpr, auto para inferencia de tipos

Modismos comunes en C

Puntero opaco (encapsulación)

// header
typedef struct Handle Handle;
Handle* handle_create(void);
void handle_destroy(Handle*);

// implementation
struct Handle { int fd; };

Devolución de llamada (puntero de función)

void sort(int* arr, int n, int (*cmp)(int, int));

Orientado a objetos (vtable manual)

struct Vtable { void (*draw)(void*); };
struct Shape { struct Vtable* vtable; };

Genérico (nulo* + puntero de función)

void qsort(void* base, size_t n, size_t size,
           int (*cmp)(const void*, const void*));