Registros

Introducción

En P1 (C) usabas struct para agrupar datos relacionados (registros).
En P2 (C++) hacemos lo mismo, pero con mejoras típicas:

• struct sigue existiendo (en C++ struct y class son muy parecidos).
• Podemos usar std::string en vez de char[].
• Es habitual pasar por referencia (T&) en vez de puntero (T*) cuando el parámetro es obligatorio.

En este tema usamos 3 ejemplos clave y un ejemplo final de modelado de datos.

---

1) Definir un robot y mostrarlo por pantalla

Define un tipo TRobot con id, modelo (cadena corta) y bateria (0–100).
Declara dos robots, inicializa uno por orden y otro por campos, y muéstralos.

P1 — C

#include <stdio.h>
#include <string.h>

#define TAM_MODELO 16

typedef struct {
    int id;
    char modelo[TAM_MODELO];
    int bateria;   // 0..100
} TRobot;

void mostrar(TRobot);

int main() {
    TRobot r1 = {1, "Scout-A", 80};
    TRobot r2 = {.id = 2, .bateria = 60};
    strcpy(r2.modelo, "Scout-B");

    mostrar(r1);
    mostrar(r2);
    return 0;
}

void mostrar(TRobot r) {
    printf("[id:%d, modelo:%s, bateria:%d%%]\n", r.id, r.modelo, r.bateria);
}

P2 — C++

#include <iostream>
#include <string>

struct Robot {
    int id;
    std::string modelo;
    int bateria; // 0..100
};

void mostrar(const Robot& r);

int main() {
    Robot r1{1, "Scout-A", 80};

    Robot r2{};
    r2.id = 2;
    r2.bateria = 60;
    r2.modelo = "Scout-B";

    mostrar(r1);
    mostrar(r2);
    return 0;
}

void mostrar(const Robot& r) {
    std::cout << "[id:" << r.id
              << ", modelo:" << r.modelo
              << ", bateria:" << r.bateria << "%]\n";
}

2) Struct + funciones: cargar batería con límite

Robot con id y bateria. Función para cargar con incremento fijo hasta un máximo y otra para consultar el nivel.

P1 — C

#include <stdio.h>

#define MAX_BAT 100
#define DELTA   15

typedef struct {
    int id;
    int bateria;
} TRobot;

void cargar(TRobot*);
int  nivel(TRobot);

int main() {
    TRobot r = {1, 0};

    cargar(&r);
    cargar(&r);
    cargar(&r);

    printf("Nivel: %d%%\n", nivel(r));
    return 0;
}

void cargar(TRobot* r) {
    int nuevo = r->bateria + DELTA;
    r->bateria = (nuevo > MAX_BAT) ? MAX_BAT : nuevo;
}

int nivel(TRobot r) {
    return r.bateria;
}

P2 — C++

#include <iostream>

constexpr int MAX_BAT = 100;
constexpr int DELTA   = 15;

struct Robot {
    int id;
    int bateria;
};

void cargar(Robot& r);         // referencia: el parámetro es obligatorio
int  nivel(const Robot& r);    // const referencia: no copiamos el struct

int main() {
    Robot r{1, 0};

    cargar(r);
    cargar(r);
    cargar(r);

    std::cout << "Nivel: " << nivel(r) << "%\n";
    return 0;
}

void cargar(Robot& r) {
    int nuevo = r.bateria + DELTA;
    r.bateria = (nuevo > MAX_BAT) ? MAX_BAT : nuevo;
}

int nivel(const Robot& r) {
    return r.bateria;
}

3) Structs anidados + colección encapsulada: sensor con diario de mediciones

Un sensor guarda mediciones (fecha y valor). Encapsulamos el diario (array + tamaño real), registramos mediciones y calculamos la media.

P1 — C

#include <stdio.h>

#define MAX_MED  100

typedef struct {
    int dia;
    int mes;
    int anyo;
} TFecha;

typedef struct {
    TFecha fecha;
    float valor;
} TMedicion;

typedef struct {
    TMedicion v[MAX_MED];
    int n;
} TDiario;

typedef struct {
    char codigo[6];
    char tipo[10];
    TDiario diario;
} TSensor;

void  registrarMedicion(TSensor*, TMedicion);
float media(TSensor);

int main() {
    TSensor s = {"T01", "TEMP", {.n = 0}};
    TMedicion m1 = {{3, 11, 2025}, 21.3f};
    TMedicion m2 = {{4, 11, 2025}, 22.1f};

    registrarMedicion(&s, m1);
    registrarMedicion(&s, m2);

    printf("Media: %.2f\n", media(s));
    return 0;
}

void registrarMedicion(TSensor* s, TMedicion m) {
    if (s->diario.n < MAX_MED) {
        s->diario.v[s->diario.n] = m;
        s->diario.n++;
    }
}

float media(TSensor s) {
    float resultado = 0.0f;
    float suma = 0.0f;

    if (s.diario.n > 0) {
        for (int i = 0; i < s.diario.n; i++) {
            suma += s.diario.v[i].valor;
        }
        resultado = suma / s.diario.n;
    }

    return resultado;
}

P2 — C++

#include <iostream>
#include <string>
#include <vector>
#include <iomanip>

struct Fecha {
    int dia, mes, anyo;
};

struct Medicion {
    Fecha fecha;
    double valor;
};

struct Sensor {
    std::string codigo;
    std::string tipo;
    std::vector<Medicion> diario;
};

void registrarMedicion(Sensor& s, const Medicion& m);
double media(const Sensor& s);

int main() {
    Sensor s{"T01", "TEMP", {}};

    Medicion m1{{3, 11, 2025}, 21.3};
    Medicion m2{{4, 11, 2025}, 22.1};

    registrarMedicion(s, m1);
    registrarMedicion(s, m2);

    std::cout << std::fixed << std::setprecision(2);
    std::cout << "Media: " << media(s) << "\n";
    return 0;
}

void registrarMedicion(Sensor& s, const Medicion& m) {
    s.diario.push_back(m);
}

double media(const Sensor& s) {
    if (s.diario.empty()) return 0.0;

    double suma = 0.0;
    for (const auto& med : s.diario) {
        suma += med.valor;
    }
    return suma / static_cast<double>(s.diario.size());
}

Recordatorio

• Un struct agrupa datos que “van juntos”.

• Si repites lógica (mostrar, añadir, calcular…), crea funciones.

• En C++ es muy habitual:

  • std::string en lugar de char[]

  • std::vector en lugar de “array + n” (n sería el tamaño del array)

  • pasar por referencia (&) para no hacer una copia y añadir const si no se va a modificar