⚡ UNET

El Lenguaje de Programación C (K&R)

Guía interactiva profunda basada exclusivamente en los Capítulos 1, 2 y 3 de Brian W. Kernighan & Dennis M. Ritchie: desde tu primer programa y flujos de E/S hasta tipos, operadores, memoria y control de flujo paso a paso.

💡

¿Qué es este Recurso Interactivo y Cómo Usarlo?

Este laboratorio web transforma los fundamentos clásicos del lenguaje C (K&R) en simuladores visuales de ejecución, inspecciones de memoria RAM en tiempo real (dirección, tipo y binario) y campos de prueba de código sin salir del navegador.

1. Explora cada Módulo: Avanza por los Capítulos 1, 2 y 3 con teoría concisa, tablas de referencia y ejemplos fieles a K&R.
2. Observa la Memoria: Cada variable y vector muestra su dirección hexadecimal, tipo de dato, valor decimal/carácter y bits.
3. Controla la Ejecución: Usa Animar, Siguiente Paso, Reiniciar y el control de velocidad para depurar cada ciclo y llamada.

Variables, Constantes, Tipos y Punto de Entrada main()

Antes de escribir código en C, comprende cómo el programa organiza los datos en memoria RAM y cómo el sistema operativo inicia y finaliza la ejecución a través de la función principal main().

main() Punto de Entrada y Valores de Retorno

Todo programa ejecutable en C debe tener exactamente una función llamada main(). Sin importar cuántas funciones existan en el archivo, el sistema operativo siempre transfiere el control primero a main().

  • int main(void): Indica que la función devuelve un número entero (int) al sistema operativo al terminar.
  • return 0;: Convención universal en C que informa al sistema operativo que el programa finalizó sin errores.
  • return 1; (o distinto de 0): Señala que ocurrió un fallo o terminación anormal.
int main(void) { /* 1. Punto de entrada */
/* 2. Instrucciones del programa */
return 0; /* 3. Estado de salida exitoso */
}
Diagrama de Flujo · Ciclo de vida de main()
Inicio (Sistema Operativo) int main(void) Reserva pila e inicia ejecución Variables, E/S e Instrucciones Ejecución secuencial línea a línea return 0; (Fin) 0 = Éxito | ≠0 = Código de error
Var Variables en Código

Una variable es un espacio con nombre en memoria RAM cuyo contenido puede cambiar durante el programa. En C debe declararse indicando su tipo antes de usarse:

int edad; /* Declaración */
edad = 20; /* Asignación */
char nota = 'A'; /* Inicialización */
Const Constantes en Código

Una constante representa un valor fijo que no puede alterarse en ejecución. En C se definen con la directiva #define o con el calificador const:

#define PI 3.1416 /* Macro simbólica */
const int MAX = 100; /* Inmutable */
Tipos Tipos de Datos Básicos

C ofrece cuatro tipos fundamentales que determinan cuánta memoria se reserva y qué valores caben:

  • int: números enteros (-5, 42).
  • float: decimales precisión simple (3.14f).
  • double: decimales doble precisión (2.71828).
  • char: un carácter ASCII ('A', '0').
Módulo 1 · K&R Capítulo 1

Introducción General (Tutorial Básico)

Anatomía inicial, E/S con formato, por qué scanf usa &, flujos de caracteres, arreglos, funciones y alcance.

1.1 Estructura Inicial y Primeros Programas en C

Selecciona cualquiera de los 4 ejemplos básicos y recórrelos paso a paso para observar cómo se crean variables en memoria RAM, cómo se imprimen con printf() y cómo se leen con scanf().

Velocidad: 800 ms
hello.cAnatomía K&R
Haz clic en cualquier línea o presiona Siguiente Paso para inspeccionar el programa.
SALIDA ESTÁNDAR (stdout)
(esperando ejecución...)
& ¿Por qué scanf() necesita el operador &?

En C, cuando llamas a una función pasando solo el nombre de la variable (ej. printf("%d", edad)), la función recibe una copia del valor y no puede modificar la variable original.

En cambio, scanf("%d", &edad) necesita guardar el dato leído dentro de tu variable. Al anteponer & ("dirección de"), le entregas a scanf la ubicación exacta en memoria RAM (por ejemplo 0x7fff0014) para que pueda escribir el nuevo valor directamente allí.

Regla práctica: printf lee el valor (sin &) · scanf escribe en la dirección (con &).
Diagrama · printf(var) vs scanf(&var)
Teclado: '25' Flujo stdin scanf("%d", &edad) Recibe dir: 0x7fff0014 RAM: 0x7fff0014 int edad = 25 Escrito directo en memoria printf("%d", edad) Solo lee copia (25)

1.2 Formato de Entrada y Salida (printf y scanf)

Tanto printf() como scanf() utilizan especificadores de conversión (precedidos por %) para interpretar los bytes de memoria según el tipo de dato correspondiente.

printf Playground de Especificadores de Formato
printf("%6.1f", 37.777);
REGLA DE CARACTERES EN PANTALLA:
% Guía Rápida de Especificadores K&R
EspecificadorTipo en CUso típico
%dintEntero decimal con signo
%ldlong intEntero largo decimal
%ffloat / doublePunto flotante (6 decimales por defecto)
%6.1ffloat / doubleMínimo 6 caracteres de ancho, 1 decimal
%ccharUn único carácter ASCII
%schar[]Cadena terminada en \0

1.3 Entrada y Salida de Caracteres (Character I/O)

El modelo de E/S estándar trata los datos como un flujo continuo de caracteres. Simula pulsaciones de teclado y observa cómo scanf()/getchar() y printf() procesan el flujo carácter por carácter.

Flujo stdin Teclado / Buffer scanf / getchar Lee 1 char c Contadores nc / nl / nw printf() stdout
Velocidad:

1.4 Vectores (Arrays) Numéricos y Cadenas de Caracteres

Los arreglos almacenan elementos del mismo tipo en direcciones contiguas de memoria. En las cadenas de C, el carácter nulo '\0' marca el fin de la cadena.

ndigit[4] Frecuencia de Dígitos (c - '0')
Entrada:
Listo para analizar dígitos '0'..'3' usando c - '0'.
\0 Cadenas: getline() y copy()
Línea leída:
char from[] (origen):
char to[] (destino tras copy):

1.5 Funciones: Paso por Valor vs Paso por Dirección (& y *)

En C todos los argumentos se pasan por valor: la función recibe una copia local en su propio marco de pila. Para que una función modifique la variable original del invocador, se pasa su dirección con & y se modifica mediante un apuntador *.

☕ Analogía Paso por Dirección vs Paso por Valor
Paso por Dirección (&taza) taza = llenarTaza( &taza ) Apunta a la taza original Paso por Valor (taza) taza = llenarTaza( copia ) Solo llena una copia local
Valor Sintaxis: sumarDiez(num)
void sumarDiez(int x) { x = x + 10; }
/* En main(): */ int num = 5; sumarDiez(num);
num:
main() enviará una copia de num a sumarDiez().
MARCO DE main() (original intacto):
MARCO DE sumarDiez(int x) (copia local):
& / * Sintaxis: sumarDiezRef(&num)
void sumarDiezRef(int *p) { *p = *p + 10; }
/* En main(): */ int num = 5; sumarDiezRef(&num);
num:
sumarDiezRef(&num) recibe la dirección real en RAM.
MARCO DE main():
MARCO DE sumarDiezRef(int *p):

1.6 Alcance (Scope): Global, Función y Bloque if { ... }

El alcance de una variable determina en qué región del código existe y puede usarse. Una variable declarada dentro de un bloque { ... } (como un if) solo vive dentro de esas llaves y queda fuera de alcance al salir.

Presiona Siguiente Paso para ver nacer y morir cada variable según su bloque.
1int global_ext = 10; /* 🟢 Alcance global */
2int main(void) {
3 int x = 20; /* 🔵 Alcance de main() */
4 if (x > 0) {
5 int bonus = 5; /* 🟣 Solo dentro del if */
6 printf("%d", global_ext + x + bonus);
7 } /* 🟣 Aquí muere 'bonus' */
8 /* bonus = 1; ❌ ERROR: fuera de alcance */
9 return 0;
10}
🟢 SEGMENTO GLOBAL (extern)
🔵/🟣 PILA AUTOMÁTICA (main e if)
Módulo 2 · K&R Capítulo 2

Tipos, Operadores y Expresiones

Tamaños de datos, constantes, conversiones de tipo, incremento prefijo/postfijo, asignaciones compuestas y precedencia.

2.1 Tipos Fundamentales, Calificadores y sizeof

Tipo / CalificadorBytes (sizeof)Rango Típico
signed char1 byte (8 bits)-128 a 127
unsigned char1 byte (8 bits)0 a 255
short int2 bytes (16 bits)-32,768 a 32,767
int4 bytes (32 bits)-2,147,483,648 a 2,147,483,647
unsigned int4 bytes (32 bits)0 a 4,294,967,295
long int8 bytes (64 bits)±9.22 × 10¹⁸
float4 bytes (IEEE 754)~6 dígitos de precisión
double8 bytes (IEEE 754)~15 dígitos de precisión
sizeof Inspector Visual de Memoria
sizeof(signed char) == 1 byte (8 bits)

2.2 Constantes Literales, Secuencias de Escape, #define, const y enum

Escapes Explorador de Literales y Secuencias
enum #define vs const vs enum
#define MAXLINE 1000 /* Sustitución textual en preprocesador */
const double e = 2.71828; /* Variable inmutable con tipo y dirección */
enum months { ENE=1, FEB, MAR, ABR }; /* FEB=2, MAR=3, ABR=4 */

2.3 Conversiones de Tipo (Implícita, Cast Explícito) y <ctype.h>

Cast Promoción Automática vs Moldeo (double)
Promoción: char (8b) ➔ int (32b) ➔ long (64b) ➔ float ➔ double
<ctype.h> Pruebas y Conversión de Caracteres

2.4 Operadores de Incremento: Prefijo (++n) vs Postfijo (n++)

Inicial: n = 5 en ambos casos.
Prefijo: x = ++n; (incrementa ANTES de usar)
Postfijo: y = n++; (usa valor, incrementa DESPUÉS)

2.6 Asignación Compuesta y Expresiones Condicionales (?:)

op= Conversor de Asignación Compuesta
x += 2 ≡ x = (x) + (2)
?: Evaluador Ternario (a > b) ? a : b
a: b:
z = 27 (se evaluó expr2)

2.7 Precedencia de Operadores y Efectos Colaterales (a[i] = i++)

NivelOperadoresAsociatividad
1 (Mayor)() [] -> .Izquierda ➔ Derecha
2 (Unarios)! ~ ++ -- + - * & (tipo) sizeofDerecha ➔ Izquierda
3 (Mult.)* / %Izquierda ➔ Derecha
4 (Adit.)+ -Izquierda ➔ Derecha
5 (Relac.)< <= > >= == !=Izquierda ➔ Derecha
6 (Lóg./Tern.)&& || ?:Izq.➔Der. (?: Der.➔Izq.)
7 (Asign.)= += -= *= /= &= <<=Derecha ➔ Izquierda
⚠️ Peligro Efectos Colaterales: a[i] = i++;

En C, el orden en que se evalúan los operandos de una asignación no está especificado. Dependiendo del compilador, a[i] = i++ escribe en índices distintos:

Selecciona un compilador para ver el comportamiento indefinido/no especificado.
Módulo 3 · K&R Capítulo 3

Control de Flujo

Decisiones if/else-if, switch-case (break vs fall-through), ciclos while, for, do-while y saltos.

3.1 Toma de Decisiones: if / else-if y switch-case

Flujo ¿Cómo decide C entre múltiples caminos?

En una cadena if / else-if / else, cada condición se evalúa en orden de arriba hacia abajo. Apenas una resulta verdadera (≠ 0), se ejecuta su bloque y se omiten todas las ramas restantes.

En cambio, switch (expr) salta directamente al case que coincida con una constante entera; si no colocas break; al final, el flujo continúa cayendo (*fall-through*) hacia los casos inferiores.

Diagrama de Flujo · Decisión if / else
condición V (≠0) F (0) Bloque if Bloque else
else-if Clasificador de Nota (0–20)
1if (nota >= 18) printf("Sobresaliente");
2else if (nota >= 10) printf("Aprobado");
3else printf("Reprobado");
switch break vs Fall-Through
case '0': ndigit++; [break;]
case '1': ndigit++; [break;]
case ' ': nwhite++; [break;]
default: nother++;

3.2 Ciclos: while, for (reverse()) y do-while (itoa())

Diagrama · while / for (Prueba Previa)
condición? V Cuerpo del ciclo F (sale)
Diagrama · do-while (Prueba Posterior ≥ 1 vez)
Cuerpo (1ra vez) condición? V (repite) F (sale)
Velocidad:
loop_while.cTraza K&R
Presiona Paso o Animar para trazar el ciclo.
IterCondiciónEstado Variables

3.3 Control de Saltos: break, continue y goto

Listo para simular saltos de control.

Autoevaluación Rápida (K&R Caps. 1–3)

Verifica tu comprensión de los fundamentos de C con retroalimentación inmediata.

1. División Entera (Cap. 1)

¿Cuál es el resultado de evaluar 5 / 9 * (68 - 32) en C?

2. Paso por Valor (Cap. 1)

Si f(x) modifica su parámetro x, ¿qué ocurre con la variable original en main()?

3. Operador ++ (Cap. 2)

Si n = 5, ¿qué valores quedan tras x = n++;?

4. Cadenas y Nulo (Cap. 1–2)

¿Cuántos bytes ocupa como mínimo la cadena literal "C" en memoria?

5. Fall-Through (Cap. 3)

En un switch, ¿qué ocurre si omites break; al final de un case coincidente?

6. Ciclos Post-Prueba (Cap. 3)

¿Por qué itoa() de K&R usa un ciclo do-while en lugar de while?