Niveles de dominio te贸rico-pr谩ctico para Plantas Industriales
Nivel 1: El GPS de la Memoria
La Abstracci贸n: Imagina la memoria RAM como una calle infinita llena de buzones. Cada buz贸n (variable) tiene un valor adentro y una direcci贸n afuera. Un puntero no es m谩s que un papelito donde anotamos la direcci贸n de un buz贸n.
Si perdemos la direcci贸n, no podemos modificar el buz贸n a la distancia. Los operadores m谩gicos son dos:
& (Ampersand): "Dame la direcci贸n de..."
* (Asterisco): "Ve a la direcci贸n y lee/escribe all铆..."
El Truco Cl谩sico: Inspeccionar Direcciones
Para ver las direcciones crudas en memoria, usamos %p en printf. Esto te permite "ver" c贸mo el SO asigna la memoria.
#include <stdio.h>
int main() {
int sensor_temp = 85;
int *gps = &sensor_temp; // gps guarda la direcci贸n
printf("Valor del sensor: %d\n", sensor_temp);
printf("Direcci贸n real (Hex): %p\n", gps);
// TRUCO: Modificaci贸n remota
*gps = 100; // El programa va a esa direcci贸n y cambia el 85 por 100
printf("Nuevo valor: %d\n", sensor_temp);
return 0;
}
Nivel 2: Modificando la Realidad (Funciones)
La Abstracci贸n: C es un lenguaje celoso. Cuando le pasas una variable a una funci贸n, hace una fotocopia exacta y le da la copia a la funci贸n. Si la funci贸n quema la copia, el original queda intacto.
驴Qu茅 pasa si queremos que una funci贸n calibre nuestro sensor y modifique la variable original del main? Le pasamos el puntero (la direcci贸n original).
El Truco: Intercambiar Valores (Swap)
Este es el ejercicio universal de punteros. Intercambiar dos valores solo es posible mediante direcciones.
#include <stdio.h>
// Recibe direcciones, no copias
void calibrar_sensores(int *val_a, int *val_b) {
int temporal = *val_a; // Guardamos lo que hay en A
*val_a = *val_b; // Metemos B en A
*val_b = temporal; // Metemos el temporal en B
}
int main() {
int s1 = 10, s2 = 90;
// Le mandamos las direcciones de s1 y s2
calibrar_sensores(&s1, &s2);
printf("S1: %d, S2: %d\n", s1, s2); // S1: 90, S2: 10
return 0;
}
Nivel 3: El Gran Enga帽o (Arrays y Strings)
La Abstracci贸n: En C, los "Arrays" no existen como entidades m谩gicas. Un array es simplemente un bloque de buzones consecutivos. 隆El nombre del array es secretamente un puntero al primer buz贸n!
Si sumamos 1 a un puntero (puntero + 1), no suma matem谩ticamente un "1", sino que avanza hacia el siguiente buz贸n saltando exactamente los bytes necesarios (ej. 4 bytes si es un int).
El Truco: Aritm茅tica de Punteros
Podemos recorrer arreglos sin usar los corchetes [].
#include <stdio.h>
int main() {
int presiones[] = {100, 110, 120};
int *p = presiones; // 'presiones' ya es una direcci贸n
printf("Primer valor: %d\n", *p); // 100
// TRUCO: Aritm茅tica pura
printf("Segundo valor: %d\n", *(p + 1)); // 110
// Lo que hace C por debajo cuando usas presiones[2]
printf("Tercer valor: %d\n", *(p + 2)); // 120
return 0;
}
Nivel 4: El Mundo Real (Structs y el ERP)
La Abstracci贸n: Un struct (como el que usaron en su TP del ERP) puede pesar cientos de bytes. Pasar eso a una funci贸n por valor es terrible para el rendimiento (sobrecarga de clonaci贸n). 隆Siempre usaremos punteros!
Cuando tenemos el puntero de un `struct`, en lugar de hacer la sintaxis tosca (*inventario).precio, los creadores de C inventaron la flecha: inventario->precio.
El Truco: Actualizaci贸n Ligera
#include <stdio.h>
typedef struct {
int id_producto;
int stock_actual;
float costo;
} ProductoERP;
// S贸lo pasamos 4 u 8 bytes (la direcci贸n), en vez de clonar todo el struct
void registrar_ingreso(ProductoERP *prod, int cantidad_recibida) {
// Usamos -> porque 'prod' es un puntero
prod->stock_actual += cantidad_recibida;
}
int main() {
ProductoERP motor = {402, 10, 150000.0};
// Lleg贸 mercader铆a al Polit茅cnico
registrar_ingreso(&motor, 5);
printf("Stock final: %d\n", motor.stock_actual); // 15
return 0;
}
馃弳 Desaf铆o Final: Preguntados C
Eval煤a tu comprensi贸n abstracta y pr谩ctica sobre punteros. Tienes un l铆mite de tiempo para demostrar tu dominio. 隆Suerte!
