Examen Parcial - 75.41. Algoritmos y Programación II

Cátedra: Mandrafina
Fecha: Primera Oportunidad - Primer Cuatrimestre 2005
Día: 20/05/2005

Dado el siguiente programa se requiere indicar lo que se mostraría por pantalla:

#include <stdlib.h>
#include <iostream>
 
using namespace std;
 
typedef int* Pint;
typedef char* Pchar;
 
/*Datos:
 '@' es 64
 'A' es 65
 ...
*/
 
int main(){
  Pint A,C,F;
  Pint* B;
  Pchar D,E;
  char G;
  int H;
 
  H = 68;
  G = 'B';
  A = new int;
  *A = 65;
  B = &C;
  F = A;
  C = &H;
  cout << **B << *A << endl;
 
  D = (char*)*B;
  E = (char*)A;
  cout << *D << *C << *E << endl;
 
  *D = G;
  if (*C == 68)
      cout << *E << *C << endl;
 
  *A = 67;
  while (*A > 0){
   cout << *A << *E << endl;
   *F = *F - H;
   *A = *A - 1;
  }
  delete A;
}

Construir los TDAs que modelen un Contenedor a partir de la siguiente descripción:

• Un Contenedor tiene forma cilíndrica, se identifica con un número, y se utiliza para almacenar sustancias líquidas.
• Cada Contenedor cuenta con un conjunto de Sensores Térmicos.
  • Un Sensor se identifica por un número, registra una temperatura, y puede estar encendido o apagado. Se pueden agregar o sacar Sensores de un Contenedor.
• La temperatura de un Contenedor se calcula como el promedio de los valores de temperatura de sus Sensores encendidos, y la capacidad medida en está dada por sus dimensiones físicas.

La empresa de Seguridad Industrial Algoritmia S.A., que se dedica a controlar el estado de Contenedores para sustancias líquidas, requiere un informe con la cantidad de Contenedores que superan una temperatura crítica T dada, para cada empresa en donde se encuentran emplazados. El informe debe tener el siguiente formato:

El listado debe estar ordenado primero por cantidad decreciente y segundo por nombre de empresa creciente.

Se dispone de 3 archivos totalmente desordenados, con la siguiente estructura, donde los campos que aparecen en negrita tienen valores únicos:

Nota:

1. Explicar la estrategia de solución adoptada con claridad (usar esquemas)
2. Los archivos se procesarán secuencialmente, una sola vez, luego en forma directa
3. Completar todo lo necesario para la resolución del problema, tipos, variables, procedimientos, etc.

Implementación del TDA Contenedor. Observar que está pensado para ser usado como objeto, utilizando punteros a Contenedor.

#include "contenedor.h"
#include <iostream>
#include "sensor.h"
 
#ifndef PI
#define PI 3.14159
#endif
 
/* ListaSensores es una lista cuyo dato tiene la siguiente definición
struct Dato{
    Sensor* sensor;
}
El ordenamiento de esa lista se hace por código de sensor
*/
struct Contenedor {
    int codigo;
    float radio;
    float alto;
    std::string sustancia;
    ListaSensores sensores;
};
 
/*
Pre: Ninguna
Post: Crea un nuevo contenedor, identificado con el código pasado, dejándolo listo para su uso
*/
void crear(Contenedor* &miContenedor, int codigo, float radio, float alto) {
    miContenedor = new Contenedor;
    miContenedor->codigo = codigo;
    miContenedor->radio = radio;
    miContenedor->alto = alto;
    miContenedor->sustancia = "Vacio";
    crearLista(miContenedor->sensores);
}
 
/*
Pre: El contenedor debe haber sido creado
Post: El contenedor queda destruido e inutilizado para su uso
*/
void destruir(Contenedor* &miContenedor) {
    Dato datoSensor;
    ptrNodoLista ptrSensor;
 
    ptrSensor = primero(miContenedor->sensores);
    while (ptrSensor != fin(miContenedor->sensores)) {
        obtenerDato(miContenedor->sensores,datoSensor,ptrSensor);
        destruir(datoSensor.sensor);
        ptrSensor = siguiente(miContenedor->sensores,ptrSensor);
    }
    eliminarLista(miContenedor->sensores);
    delete miContenedor;
    miContenedor = NULL;
}
 
/*
Pre: El contenedor debe haber sido creado
Post: Se le asigna la sustancia pasada al contenedor
*/
void setSustancia(Contenedor* &miContenedor, string sustancia) {
    miContenedor->sustancia = sustancia;
}
 
/*
Pre: El contenedor debe haber sido creado, al igual que el sensor a agregar
Post: Agrega el sensor a los pertenecientes al Contenedor
*/
void agregarSensor(Contenedor* &miContenedor, Sensor* &miSensor) {
    Dato datoSensor;
 
    datoSensor.sensor = miSensor;
    insertarDato(miContenedor->sensores,datoSensor);
}
 
/*
Pre: El contenedor debe haber sido creado, al igual que el sensor a quitar
Post: Si el sensor existía en el contenedor, es quitado y retorna True. En caso contrario retorna false
*/
bool quitarSensor(Contenedor* &miContenedor, Sensor* &miSensor) {
    Dato datoSensor;
    ptrNodoLista ptrSensor;
    bool encontrado = false;
 
    ptrSensor = primero(miContenedor->sensores);
    while  ((ptrSensor != fin(miContenedor->sensores)) && (!encontrado)) {
        obtenerDato(miContenedor->sensores,datoSensor,ptrSensor);
        if (sonIguales(datoSensor.sensor,miSensor)) {
            encontrado = true;
            destruir(datoSensor.sensor);
            eliminarNodo(miContenedor->sensores,ptrSensor);
        }
        ptrSensor = siguiente(miContenedor->sensores,ptrSensor);
    }
    return encontrado;
}
 
/*
Pre: El contenedor debe haber sido creado
Post: Retorna el código del Contenedor
*/
int getCodigo(Contenedor* &miContenedor) {
    return miContenedor->codigo;
}
 
/*
Pre: El contenedor debe haber sido creado
Post: Retorna el radio del Contenedor
*/
float getRadio(Contenedor* &miContenedor) {
    return miContedor->radio;
}
 
/*
Pre: El contenedor debe haber sido creado
Post: Retorna el alto del Contenedor
*/
float getAlto(Contenedor* &miContenedor) {
    return miContenedor->alto;
}
 
/*
Pre: El contenedor debe haber sido creado
Post: Retorna el volumen del Contenedor
*/
float getVolumen(Contenedor* &miContenedor) {
    float base;
    base = getRadio(miContenedor);
    base *= base*PI;
    return base*getAlto(miContenedor);
}
 
/*
Pre: El contenedor debe haber sido creado
Post: Retorna el nombre de la sustancia guardada en el contenedor
*/
string getSustancia(Contenedor* &miContenedor) {
    return miContenedor->sustancia;
}
 
/*
Pre: El contenedor debe haber sido creado
Post: Retorna la temperatura promedio del Contenedor
*/
float getTemperaturaPromedio(Contenedor* &miContenedor) {
    Dato datoSensor;
    ptrNodoLista ptrSensor;
    int cantidadSensores = 0;
    float temperaturaTotal = 0;
 
    ptrSensor = primero(miContenedor->sensores);
    while (ptrSensor != fin(miContenedor->sensores)) {
        obtenerDato(miContenedor->sensores,datoSensor,ptrSensor);
        if (getEstado(datoSensor.sensor)) {
            cantidadSensores++;
            temperaturaTotal += getTemperatura(datoSensor.sensor);
        }
        ptrSensor = siguiente(miContenedor->sensores,ptrSensor);
    }
    if (cantidadSensores != 0) {
        return (temperaturaTotal/cantidadSensores);
    }
    else {
    return ERROR:
    }
}

Implementación del TDA Sensor. Observar que está pensado para ser usado como objeto, utilizando punteros a Sensor.

const float ERROR = -999999;
 
struct Sensor {
    int codigo;
    bool activado;
    float temperatura;
};
 
/*
Pre: Ninguna
Post: Crea un nuevo sensor, identificado con el código pasado, dejándolo listo para su uso.
Por defecto el sensor está desactivado y la temperatura marcada es ERROR
*/
void crear(Sensor* &miSensor, int codigo) {
    miSensor = new Sensor;
    miSensor->codigo = codigo;
    miSensor->activado = false;
    miSensor->temperatura = ERROR;
}
 
/*
Pre: El sensor debe haber sido creado
Post: Destruye el sensor, dejándolo intulizable
*/
void destruir(Sensor* &miSensor){
    delete miSensor;
    miSensor = NULL;
}
 
/*
Pre: El sensor debe haber sido creado
Post: Activa el sensor
*/
void activar(Sensor* &miSensor){
    miSensor->activado = true;
}
 
/*
Pre: El sensor debe haber sido creado
Post: Desactiva el sensor
*/
void desactivar(Sensor* &miSensor){
        miSensor->activado = false;
}
 
/*
Pre: El sensor debe haber sido creado
Post: Cambia la temperatura marcada por el sensor
*/
void setTemperatura(Sensor* &miSensor, float temperatura){
    miSensor->temperatura = temperatura;
}
 
/*
Pre: El sensor debe haber sido creado
Post: Retorna el código del sensor
*/
int getCodigo(Sensor* &miSensor){
    return miSensor->codigo;
}
 
/*
Pre: El sensor debe haber sido creado
Post: Retorna el estado del sensor:
    True: Activado
    False: Desactivado
*/
bool getEstado(Sensor* &miSensor){
    return miSensor->estado;
}
 
/*
Pre: El sensor debe haber sido creado
Post: Retorna la temperatura medida actualmente por el sensor
*/
float getTemperatura(Sensor* &miSensor){
    return miSensor->temperatura;
}
 
/*
Pre: Los dos sensores deben haber sido creados
Post: Retorna true si los sensores son iguales, false en caso contrario
*/
bool sonIguales(Sensor* &a, Sensor* &b){
    return (getCodigo(a) == getCodigo(b);
}