Inicio / Directorio / Informática y Telecomunicaciones /

Estructuras en C++ para Gestión Hospitalaria: Médicos, Departamentos y Medicamentos con Ejemplos Prácticos

Informática y Telecomunicaciones11,01 KB

Boletín 4: Estructuras de Datos en C/C++

1. Definición de constantes y tipos

En el fichero estructura.h se definen las constantes y los tipos de datos necesarios para la aplicación:

#define MAXCAR 256      // Longitud máxima de una cadena
#define MAXMEDICOS 25   // Número máximo de médicos por departamento
#define MAXDPTO 15      // Número máximo de departamentos
#define MAX 20          // Tamaño máximo genérico de tablas

typedef char Cadena[MAXCAR];  // Definición de tipo cadena de caracteres

typedef enum {residente, adjunto, interino} Categoria;  // Tipo enumerado con las categorías profesionales

2. Estructura Médico

La estructura Medico agrupa los datos de un profesional sanitario:

typedef struct {
    Cadena nombre;
    Cadena apellidos;
    int edad;
    double horasSemanales;
    // La categoría profesional se representa mediante un tipo enumerado (enum),
    // ya que solo puede tomar tres valores: residente, adjunto o interino.
    Categoria categoriaProf;
    bool trabajaEnPrivada;
} Medico;

Además, se declara la función de lectura de un médico residente:

Medico LeeMedicoResidente();

3. Estructuras Departamento y Hospital

Un departamento contiene un nombre, una tabla de médicos y el número de médicos efectivos:

typedef Medico TablaMedicos[MAXMEDICOS];

typedef struct {
    Cadena nombre;
    TablaMedicos medicos;
    int numMedicos;
} Departamento;

typedef Departamento TablaDepartamentos[MAXDPTO];

typedef struct {
    Cadena direccion;
    TablaDepartamentos departamentos;
    int numDepartamentos;
} Hospital;

4. Estructuras Medicamento y Farmacia

Un medicamento incluye su código, precio, posología, principios activos y si requiere receta médica:

typedef Cadena TablaPrinpActiv[MAX];

typedef struct {
    Cadena nombre;
    int codigo;
    double precio;
    Cadena posologia;
    TablaPrinpActiv pripActivos;
    int numPActivo;
    bool recetaMedica;
} Medicamento;

typedef Medicamento TablaMedicamentos[MAX];
typedef int TablaUnidades[MAX];

typedef struct {
    Cadena direccion;
    Cadena Identificador;
    TablaMedicamentos medicamentos;
    TablaUnidades unidadesMed;
    int numMedicamentos;
} Farmacia;

5. Prototipos de funciones

Las cabeceras de las funciones se declaran en el mismo fichero de cabecera:

Medico LeeMedicoResidente();
int leeMedicosResidentes(TablaMedicos);
Departamento leeDepartamento();
Medico medicoEnDptoConMayorNumeroHora(Departamento);
int medicosNoTrabajanEnLaPrivada(Departamento, TablaMedicos);
int numMedicosConCategoria(Departamento, Categoria);
void mostrar(Medico);
Medicamento leeMedicamentoConReceta();

6. Programa de prueba (test_estructura.cpp)

El programa principal valida las funciones implementadas. Algunos bloques se han comentado para probar los ejercicios por separado:

#include 
#include 
using namespace std;
#include "estructura.h"

int main() {
    cout << "INICIO DE PROGRAMA\n\n";

    Medico m;
    Medicamento me;
    TablaMedicos tMed;
    TablaMedicos tMNoPrivada;
    int numMed;
    Departamento dpto;
    Medico medicosMasHoras;
    int nmC;
    int res;
    Hospital h;
    int i, numNoP;

    /* EJERCICIO 1
    m = LeeMedicoResidente();
    printf("\tNombre: %s\n", m.nombre);
    printf("\tApellidos: %s\n", m.apellidos);
    printf("\tEdad: %d\n", m.edad);
    printf("\tHoras semanales: %lf\n", m.horasSemanales);
    printf("\tCategoría: %d\n", m.categoriaProf);
    printf("\tTrabaja en privada: %d\n", m.trabajaEnPrivada);

    EJERCICIO 2
    numMed = leeMedicosResidentes(tMed);
    for (i = 0; i < numMed; i++)
        mostrar(tMed[i]);

    EJERCICIO 3
    dpto = leeDepartamento();
    printf("El departamento es: ");
    printf("\tNombre: %s", dpto.nombre);
    printf("Número de médicos: %d", dpto.numMedicos);
    for (i = 0; i < dpto.numMedicos; i++)
        mostrar(dpto.medicos[i]);

    EJERCICIO 4
    medicosMasHoras = medicoEnDptoConMayorNumeroHora(dpto);
    printf("El médico que trabaja más horas es: ");
    mostrar(medicosMasHoras);

    EJERCICIO 5
    numNoP = medicosNoTrabajanEnLaPrivada(dpto, tMNoPrivada);

    EJERCICIO 6
    nmC = numMedicosConCategoria(dpto, interino);

    EJERCICIO 8
    // res = numDptoConMasDeNMed(h, 25);
    // cout << "El resultado es: " << res << endl;
    */

    // EJERCICIO 12
    printf("----EJERCICIO 12----");
    me = leeMedicamentoConReceta();
    printf("\tNombre: %s\n", me.nombre);
    printf("\tCódigo: %d\n", me.codigo);
    printf("\tPrecio: %lf\n", me.precio);
    printf("\tPosología: %s\n", me.posologia);
    printf("\tPrincipio activo: %s\n", me.pripActivos);

    cout << "\nFIN DE PROGRAMA\n";

    return 0;
}

7. Implementación de funciones (estructura.cpp)

Ejercicio 1: Lectura de un médico residente

Medico LeeMedicoResidente() {
    Medico res;

    printf("\nLectura de datos de un médico.\n");
    printf("Introduzca un nombre: ");
    scanf("%s", res.nombre);   // Las cadenas de caracteres no necesitan el operador &

    printf("Introduzca un apellido: ");
    scanf("%s", res.apellidos);

    printf("Introduzca la edad: ");
    scanf("%d", &res.edad);

    printf("Introduzca las horas semanales: ");
    scanf("%lf", &res.horasSemanales);

    res.categoriaProf = residente;
    res.trabajaEnPrivada = false;

    return res;
}

Ejercicio 2: Lectura de un array de médicos residentes

int leeMedicosResidentes(TablaMedicos tm) {
    int num;
    int i;
    Medico m;

    cout << "Introduzca el número de médicos para la tabla: ";
    cin >> num;

    for (i = 0; i < num; i++) {
        m = LeeMedicoResidente();
        tm[i] = m;
    }
    return num;
}

Ejercicio 3: Lectura de un departamento

Departamento leeDepartamento() {
    Departamento res;

    printf("Introduzca el nombre del departamento: ");
    scanf("%s", res.nombre);   // Corregido: el formato debe ser "%s"

    res.numMedicos = leeMedicosResidentes(res.medicos);

    return res;
}

Ejercicio 4: Médico con mayor número de horas

Medico medicoEnDptoConMayorNumeroHora(Departamento d) {
    Medico max = d.medicos[0];   // Inicializamos max con el primer médico
    int i;

    for (i = 1; i < d.numMedicos; i++) {
        if (max.horasSemanales < d.medicos[i].horasSemanales) {
            max = d.medicos[i];
        }
    }
    return max;
}

Ejercicio 5: Médicos que no trabajan en la privada

int medicosNoTrabajanEnLaPrivada(Departamento d, TablaMedicos tm) {
    // tm es un parámetro de salida: se inicia vacío y se rellena con los médicos
    // que no trabajan en la privada
    int numMed = 0;
    int i;

    for (i = 0; i < d.numMedicos; i++) {
        if (d.medicos[i].trabajaEnPrivada == false) {
            tm[numMed] = d.medicos[i];
            numMed++;
        }
    }
    return numMed;
}

Ejercicio 6: Número de médicos por categoría

int numMedicosConCategoria(Departamento d, Categoria c) {
    int i, res = 0;   // Contador

    for (i = 0; i < d.numMedicos; i++) {
        if (d.medicos[i].categoriaProf == c) {
            res = res + 1;   // Equivale a res++
        }
    }
    return res;
}

Ejercicio 8: Departamentos con más de n médicos

int numDptoConMasDeNMed(Hospital h, int n) {
    int i;
    int cont = 0;

    for (i = 0; i < h.numDepartamentos; i++) {
        if (h.departamentos[i].numMedicos > n) {
            cont++;   // Equivale a cont = cont + 1
        }
    }
    return cont;
}

Ejercicio 9: Media de horas y departamento con menor carga laboral

double mediaHoras(Departamento d) {
    int i;
    double m = 0;

    for (i = 0; i < d.numMedicos; i++) {
        m = m + d.medicos[i].horasSemanales;
    }
    m = m / d.numMedicos;
    return m;
}

int dptoMenorCargaLaboral(Hospital h) {
    int i;
    double aux, mediaMin = mediaHoras(h.departamentos[0]);
    int pos = 0;

    for (i = 1; i < h.numDepartamentos; i++) {
        aux = mediaHoras(h.departamentos[i]);
        if (aux < mediaMin) {
            mediaMin = aux;
            pos = i;
        }
    }
    return pos;
}

Ejercicio 10: Médicos que trabajan más de n horas en un departamento

int medicosTrabajanMas(Hospital h, Cadena nom, int n, TablaMedicos tm) {
    int i, j;
    int pos = 0;

    for (i = 0; i < h.numDepartamentos; i++) {
        if (strcmp(h.departamentos[i].nombre, nom) == 0) {
            for (j = 0; j < h.departamentos[i].numMedicos; j++) {
                if (h.departamentos[i].medicos[j].horasSemanales > n) {
                    tm[pos] = h.departamentos[i].medicos[j];
                    pos++;
                }
            }
            break;
        }
    }
    return pos;
}

Ejercicio 12: Lectura de un medicamento con receta

Medicamento leeMedicamentoConReceta() {
    Medicamento m;

    printf("Introduzca un nombre de medicamento: ");
    scanf("%s", m.nombre);

    printf("Introduzca el código: ");
    scanf("%d", &m.codigo);

    printf("Introduzca el precio: ");
    scanf("%lf", &m.precio);

    printf("Introduzca la posología: ");
    scanf("%s", m.posologia);

    printf("Introduzca los principios activos: ");
    scanf("%s", m.pripActivos);

    // m.numPActivo = leeMedicamentoConReceta(m.pripActivos);
    m.recetaMedica = true;

    return m;
}

int leePrincipiosActivos(TablaPrinpActiv l) {
    int i, numElems;

    printf("Introduzca el número de principios activos: ");
    scanf("%d", &numElems);

    for (i = 0; i < numElems; i++) {
        printf("Introduzca el nombre del principio activo: ");
        scanf("%s", l[i]);
    }
    return numElems;
}

Ejercicio 15: Medicamentos sin receta con unidades superiores a n

int medicamentosSinR(Farmacia f, int n, TablaMedicamentos tm) {
    int i;
    int pos = 0;

    for (i = 0; i < f.numMedicamentos; i++) {
        if (f.medicamentos[i].recetaMedica == false && f.unidadesMed[i] > n) {
            tm[pos] = f.medicamentos[i];
            pos++;
        }
    }
    return pos;
}

8. Conceptos clave

  • struct: permite agrupar datos de distinto tipo bajo un mismo nombre.
  • enum: define un tipo con un conjunto finito de valores constantes.
  • typedef: crea alias de tipos para mejorar la legibilidad del código.
  • Paso de arrays a funciones: los arrays se pasan por referencia, por lo que los cambios realizados dentro de la función son visibles en el llamador.
  • Prototipos: declaran la firma de una función antes de su implementación.

Descargar

PDF Word HTML