/* Este programa ha sido realizado por Pablo Ruiz y Fernando Hueso en la asignatura:
   Técnicas informáticas, Prácticas de Laboratorio. 1º de Física, curso 2007-08.
   Nombre del Programa: Estaciones meteorológicas
   Propósito: Sistema de Gestión de los pluviómetros de las estaciones meteorológicas
   de la Comunidad Valenciana.
*/

//Errores detectados: si introduces numeros mayores que el límite del tipo de dato.
//Si el fichero no sigue la estructuración lógica.
//Si en lugar de un caracter introduces una cadena (error controlado hasta cadena de TAM caracteres)
// o en lugar de un numero una cadena. En algunos casos entra en un bucle infinito
//El resto de ocurrencias se han controlado.

#include<iostream>
#include<string>
#include<fstream>
using namespace std;

//Constantes
#define LIT 12
#define TAM 100//Nº maximo de municipios.

//Estructuras
struct estacion
{
       unsigned short cod;
       string mun;
       float litros[LIT];
};

//PROTOTIPOS DE FUNCIONES
int main();

//inicialización
void inicio(string &fich,unsigned short &num,unsigned short &num2,struct estacion x[TAM]);
unsigned short volcar (ifstream &f, string fich, struct estacion x[TAM]);

//recurrentes
char menu(char &op);
unsigned short codigo(string nombre);
int buscamu(struct estacion x[TAM], unsigned short num, string mun);
void error();

//a
void buscar(struct estacion x[TAM], unsigned short num);

//b
void escribir (struct estacion x[TAM], unsigned short num);
void mostrarmu (int pos, struct estacion x[TAM]);
void mostrarlit (float v[LIT]);

//c
void insertar (string mun,struct estacion x[TAM], unsigned short &num2);
void ins(struct estacion x[TAM],unsigned short &num2);

//d
void guardar (string fich, struct estacion x[TAM], unsigned short &num, unsigned short num2);

//e,f,g
void munprov (struct estacion x[TAM], unsigned short num);
void horas (struct estacion x[TAM], unsigned short num);
void comval (struct estacion x[TAM], unsigned short num);
void iwal (float a, float &b);
void comparar (float v, float &max, float &min, float &med);

//h
void modificar (struct estacion x[TAM],unsigned short num, string fich);
void reemplazar (struct estacion x[TAM],unsigned short num, string fich);

//j
void salir(string fich,struct estacion x[TAM],unsigned short &num,unsigned short num2);

/*Función: Volcar fichero
Descripción de la función: Volcar fichero a un vector de estructuras separado por campos
Parámetros: fichero de lectura f por referencia, nombre del fichero fich y vector
con las estructuras.
Detalles: devuelve error si no encuentra el fichero y no hace nada más, si lo
encuentra lo rellena hasta fin de fichero, y devuelve i, que es el nº de elementos
que se han rellenado en la estructura.
Esto será utilizado para saber hasta donde leer en el array. Si hay error,
devuelve 0 (o si el fichero está vacío).
Por tanto no realizará acciones en otras operaciones.*/
unsigned short volcar (ifstream &f, string fich, struct estacion x[TAM])
{
       unsigned short i=0, j;
       f.open(fich.c_str());
       if (!f)
       {
          cout << "Error.\n";
       }
       else
       {
           for (i=0; f>>x[i].cod;i++)//el fichero no acaba con un salto de linea,
           //pero como comprobamos con f>>x[i].cod, no hay problema y no entra en el bucle.
           {
               f.ignore();//ignora el tabulador
               getline(f,x[i].mun);
               for (j=0; j<LIT; j++)
               {
                   f>>x[i].litros[j];
               }
           }
           f.close();
       }
       return i;
}

/*Función: Escribir en pantalla
Descripción de la función: Muestra las estructuras guardadas en el vector
de forma ordenada y tabulada.
Parámetros: array de estructuras (Automáticamente por referencia), num: numero
hasta donde leer el array. (cuántas estaciones hay guardadas)
Detalles: es un procedimiento. Llama a la función base de escribir un municipio.
No tiene en cuenta las modificaciones si no se ha actualizado antes.*/
void escribir (struct estacion x[TAM], unsigned short num)
{
       int i;
       cout << endl;
       for (i=0; i<num;i++)
       {
           mostrarmu(i,x);
       }
}

/*Función: Guardar en fichero
Descripción de la función: Actualiza los datos de memoria volcándolos en fichero.
Parámetros: num, num2: indican el nº de estaciones original y el nº que habrá después de actualizar.
num se pasa por referencia porque después, num=num2; (al empezar el programa, sucede lo mismo)
fichero de escritura g, nombre del fichero, vector de estructuras.
Detalles:
Por tanto si no se han hecho modificaciones, no entrará en el bucle y no realizará nada.
Si se han hecho modificaciones, num2 será mayor que num y se añadirá a final de fichero,
por eso ios::app.
*/
void guardar (string fich, struct estacion x[TAM], unsigned short &num, unsigned short num2)
{
       unsigned short i, j;
       ofstream g;
       g.open(fich.c_str(), ios::app);
       if (!g)
       {
          cout << "Error.\n";
       }
       else
       {
           if (num==num2)
           {
               cout << "Se mantiene el original al no haberse realizado modificaciones.\n";
           }
           else
           {
               
               for (i=num; i<num2; i++)
               {
                   g<<endl;//el fichero no acaba en un salto de linea, sino que
                   //lo ponemos nosotros nada más empezar.
                   g<<x[i].cod<< "\t";
                   g<<x[i].mun<< "\n";
                   for (j=0; j<LIT-1; j++)
                   {
                       g<<x[i].litros[j]<<"\t";
                   }
                   g << x[i].litros[j];
               }
               g.close();//al cerrarlo por tanto no añadimos ningun salto de linea.
               //también se podría hacer al revés...
               num=num2;
               cout << "Datos actualizados correctamente.\n";
           }
       }
}

/*Función: Buscar municipio
Descripción de la función: Busca un municipio recorriendo el vector de estructuras
Parámetros: Vector de estructuras x, num: indica cuántas posiciones hay llenas,
string mun (nombre del municipio)
Devuelve: posición donde encuentra el municipio en el vector. Si no lo encuentra,
devuelve -1.
Detalles: Cuando lo encuentra, i=num para que salga del bucle (no hay más de una
vez el mismo municipio)*/
int buscamu(struct estacion x[TAM], unsigned short num, string mun)
{
     unsigned short i;
     int pos=-1;
     for (i=0; i<num;i++)
     {
         if (x[i].mun==mun)
         {
             pos=i;
             i=num;
         }
     }
     return pos;
}

/*Función: Mostrar linea de todos los litros.
Descripción de la función: Escribe por pantalla los litros.
Parámetros: vector de litros v, (se le pasa el campo litros de la estructura*/
void mostrarlit (float v[LIT])
{
       unsigned short j;
       for (j=0; j<LIT; j++)
       {
           cout.precision(3);
           cout << v[j] << "\t";
       }
       cout << endl;
}



/*Función: Mostrar observación
Descripción de la función: Escribe por pantalla los datos de una estación
Parámetros: posición, vector de estructuras x
Detalles: Saca los datos en el mismo formato que el txt, excepto que añade CP:
para no confundir visualmente el código de provincia con los litros.*/
void mostrarmu (int pos, struct estacion x[TAM])
{

       cout << "CP:" << x[pos].cod << "\t";
       cout << x[pos].mun << "\n";
       mostrarlit (x[pos].litros);
       cout << endl;//sacamos un salto de linea para que sea más legible.

}


/*Función: Insertar observación
Descripción de la función: Pide los datos de una estación entera y los rellena
en la estructura a continuación de donde estaba la última en el vector.
Parámetros: posición, vector de estructuras x, num2 por referencia
(devolverá hasta dónde llega ahora la estructura modificada)
Detalles: Da error si no es la estructura adecuada. guarda num2 por si se actualiza
después, para que simplemente escriba a continuación de lo último que había en el fichero.*/
void insertar (string mun,struct estacion x[TAM], unsigned short &num2)
{
     unsigned short i;
     string nombre;
     
     cout << "A que provincia pertenece? Escribe Valencia, Castellon o Alicante.\n";
     getline(cin,nombre);
     
     if (codigo(nombre)==0)
     {
         error();
     }
     else
     {
         x[num2].cod=codigo(nombre);
         x[num2].mun=mun;
         cout << "Introduce ahora los litros de cada una de las ultimas doce horas ";
         cout << "separado por intros.\n";
         for (i=0;i<LIT;i++)
         {
             cin >> x[num2].litros[i];
         }
         cin.ignore(TAM,'\n');//para que no se acumule el error posteriormente si alguien no mete
         //datos de tipo float.
         num2=num2+1;
         cout << "Datos cargados correctamente.\n";
     }  
}

/*Función: Reconoce código
Descripción de la función: Dado el nombre de la provincia le asigna el código correspondiente.
Parámetros: Nombre (string) de la provincia
Devuelve: con return el código de provincia, un cero en caso de que no exista la provincia dada.
Detalles: El string que le pasan tiene que ser idéntico, no puede haber espacios al final
ni comas ni nada por el estilo.*/
unsigned short codigo(string nombre)
{
     if (nombre=="Valencia")
     {
         return 46;
     }
     else
     {
         if (nombre=="Alicante")
         {
                return 3;
         }
         else
         {
             if (nombre=="Castellon") 
             {
                 return 12;
             }
             else
             {
                  return 0;
             }
         }
     }
}

/*Función: Mensaje de error
Descripción de la función: Muestra un mensaje de error base utilizado en los
menús cuando se introduce un dato no permitido.
Detalles: Procedimiento, no tiene parámetros ni devuelve nada. Sólo saca el mensaje.*/
void error()
{
     cout << "Error, se reinicia el menu.\n";
}

/*Función: Comparación de valores
Descripción de la función: Va comparando valores y encuentra maximos y minimos. Ademas, calcula la suma de valores, para la media.
Parametros.*/
void comparar (float v, float &max, float &min, float &med)
{
     if (v>max)
     {
         max=v;
     }
     else
     {
         if (v<min)
         {
             min=v;
         }
     }
     med=med+v;
}


/*Función: Igualación
Descripción de la función: Iguala el primer parámetro al segundo. Sirve para inicializar
los maximos medios y minimos con el valor del primer elemento de la comparación
Parámetros: Un valor real a y otro b, este último por referencia*/
void iwal (float a, float &b)
{
     b=a;
}

/*Función: case 'e' 
Descripción de la función: Pregunta si se desea calcular de una provincia o
municipio y llamando a la función maxminmed calcula las maxima, media y minima
precipitaciones del municipio; para una provincia lo calcula ella misma
Parámetros: el vector de estructuras x y el número num de entradas del fichero*/
void munprov (struct estacion x[TAM], unsigned short num)
{
     unsigned short cod;
     char q;
     int pos, i, j, k=0;
     float max, min, med;
     string mun, nombre;
     
     cout << "Introduce 'M' para calcular la maxima media y minima de un municipio";
     cout << " o 'P' para calcular lo mismo pero de una provincia.\n";
     
     cin.get(q);
     cin.ignore(TAM, '\n');//precaución por si has metido mas de un caracter, para que no
     //se ralle y de varias vueltas al menu....
     
     if (q=='M' || q=='m')
     {
            cout << "Introduce el nombre del municipio exactamente, mayuscula la";
            cout << " primera, y sin acentos.\n";
            getline(cin,mun);
            if ((pos=buscamu(x, num, mun))==-1)
            {
                error();
                cout << "Municipio no existente.\n";
                cout << "Comprueba que lo has escrito correctamente distinguiendo";
                cout << " mayusculas de minusculas.\n";
            }
            else
            {
                pos=buscamu(x,num,mun);
                iwal (x[pos].litros[0],max);
                iwal (x[pos].litros[0],min);
                iwal (x[pos].litros[0],med);
                for (i=1; i<LIT; i++)
                {
                    comparar(x[pos].litros[i],max,min,med);
                }
                med=med/LIT;
                cout << "\nLa precipitacion maxima de " << mun << " fue ";
                cout << max << ", la minima " << min;
                cout << " y la media " << med << ".\n";
            }
     }
     else
     {
         if (q=='P' || q=='p')
         {
            cout << "De que provincia deseas calcular la maxima media y minima?";
            cout << " Escribe 'Valencia', 'Castellon' o 'Alicante'.\n";
            getline (cin,nombre);//ignore?
            cod=codigo(nombre);
            if (cod==0)
            {
                error();
            }
            else
            {
                for (i=0; i<num; i++)
                    {
                        if (x[i].cod==cod)
                        {
                           
                            iwal (x[i].litros[0],max);
                            iwal (x[i].litros[0],min);
                            med=0;
                            i=num;//inicializamos con el primero.
                        }
                    }
                for (i=0; i<num; i++)
                {
                    if (x[i].cod==cod)//volvemos a pasar por el primero porque falta la media.
                    {
                       for (j=0; j<LIT; j++)
                       {
                           comparar(x[i].litros[j],max,min,med);
                       }
                       k++;
                    }
                }
                if (k==0)
                {
                         error();
                         cout << "No existen municipios.\n";
                }
                else
                {
                    med=med/(k*LIT);
                    cout << "\nLa precipitacion maxima de " << nombre << " fue ";
                    cout << max << ", la minima " << min;
                    cout << " y la media " << med << ".\n";
                }
            }
         }
         else
         {
             error ();
         }
     }  
}

/*Función: case 'f' 
Descripción de la función: Calcula la maxima media y minima de cada hora para una provincia dada.
Parámetros: el vector de estructuras x y el número num de entradas del fichero*/
void horas (struct estacion x[TAM], unsigned short num)
{
    float max[LIT], min[LIT], med[LIT];
    string nombre;
    unsigned short cod, i, j, k=0;
    
    cout << "Dime el nombre de la provincia de la que quieres calcular ";
    cout << "los maximos, minimos y medios por hora. (Alicante, Castellon o Valencia)\n";
    getline(cin,nombre);
    cod=codigo(nombre);
    if (cod==0)
    {
        error();
    }
    else
    {
        for (i=0; i<num; i++)
        {
            if (x[i].cod==cod)
            {
               for (j=0; j<LIT; j++)
               {
                    iwal (x[i].litros[j],max[j]);
                    iwal (x[i].litros[j],min[j]);
                    med[j]=0;
               }
               i=num;
            }
        }
         
        for (j=0; j<LIT; j++)
        {
            for (i=0; i<num; i++)
            {    
               if (x[i].cod==cod)
               {
                   k++;
                   comparar (x[i].litros[j], max[j], min[j], med[j]);
               }
            }
        }
        if (k==0)
        {
                 error ();
                 cout << "No existen municipios.\n";
        }
        else
        {
            k=k/12;
            for (j=0; j<LIT; j++)
            {
                med[j]=med[j]/k;
            }
            cout << "Maximos:\t";
            mostrarlit(max);
            cout << "Minimos:\t";
            mostrarlit(min);
            cout << "Medias:  \t";
            mostrarlit(med);
        }
    } 
}


/*Función: case 'g' 
Descripción de la función: Calcula la maxima media y minima de la comunidad valenciana
Parámetros: el vector de estructuras x y el número num de entradas del fichero*/
void comval (struct estacion x[TAM], unsigned short num)
{
    int i, j;
    float max, min, med;
    iwal (x[0].litros[0],max);
    iwal (x[0].litros[0],min);
    med=0;
    
    
    for (i=0; i<num; i++)
    {           
       for (j=0; j<LIT; j++)
       {
         comparar(x[i].litros[j], max, min, med);
       }
    }
    med=med/(i*LIT);
    cout << "\nLa precipitacion maxima de la Comunidad Valenciana fue " << max;
    cout << ", la minima " << min;
    cout << " y la media " << med << ".\n";
     
}
/*Función: Mostrar menú y guardar opción
Descripción de la función: Muestra el menú y guarda la opción pulsada
Parámetros: por referencia el carácter op (si no es un case del menú se filtrará
por el default)*/
char menu (char &op)
{
   cout << "Pulsa lo que quieras hacer:\na. Buscar observacion por municipio\n";
   cout << "b. Visualizar todas las observaciones.\n";
   cout << "c. Insertar una observacion de un municipio no existente.\n";
   cout << "d. Actualizar datos.\n";
   cout << "e. Precipitacion maxima, minima y media de un municipio o provincia.\n";
   cout << "f. Precipitacion maxima, minima y media de cada hora para una provincia.\n";
   cout << "g. Precipitacion maxima, minima y media para toda la Comunidad Valenciana.\n";
   cout << "h. Modificar los litros recogidos en un municipio en las ultimas 12 horas.\n";
   cout << "i. Limpiar pantalla y reiniciar menu.\nj. Salir.\n";

   cin >> op;
   cin.ignore(TAM,'\n');//controla el error si metes una cadena hasta de TAM caracteres.
   return op;
}

/*Función: Inicializar programa
Descripción de la función: Carga el nombre del fichero en una variable que se
utilizará en adelante. (No la pide, sino que se escribe en el código, para que cuando
se quiera cambiar desde el código, sólo haya que cambiar en este punto el nombre.)
Además carga los datos llamando a la función volcar, y establece el número
relleno de posiciones del vector de estructuras.
Parámetros: por referencia el string fich con el nombre, los numeros num y num2
por referencia, y el array de estructuras.
Detalles: num=num2 para que cuando actualice no haga nada, pues no se ha modificado nada.
Si se modifica algo num2 será mayor y guardará tantas nuevas estaciones como num2-num1.
*/
void inicio(string &fich,unsigned short &num,unsigned short &num2,struct estacion x[TAM])
{
    ifstream f;
    fich="precipitaciones.txt";
    num=volcar(f,fich, x);
    num2=num;
}

/*Función: case a
Descripción de la función: Busca un municipio y llama a la función para que muestra la observación
Parámetros: Vector de estructuras x
Detalles: Filtro de errores si buscas un municipio no existente (buscamu devuelve
-1 y saca mensaje de error. En caso de que exista llama a mostrarmu que muestra la observación.
*/
void buscar(struct estacion x[TAM], unsigned short num)
{
    int pos;
    string mun;
    cout << "Introduce el nombre del municipio exactamente, mayuscula la primera, y sin acentos.\n";
    getline(cin,mun);
    if ((pos=buscamu(x, num, mun))==-1)
    {
        error();
        cout << "Municipio no existente.\n";
        cout << "Comprueba que lo has escrito correctamente distinguiendo";
        cout << " mayusculas de minusculas.\n";
    }
    else
    {
        mostrarmu(pos,x);
    }
}

/*Función: case j
Descripción de la función: Salir y preguntar antes si debe guardar
Parámetros: Vector de estructuras x, nombre de fichero fich, num y num2 que marcan
posición original y modificada (cuántas estaciones se han añadido),
fichero de escritura que se utiliza en el caso de que se quiera guardar.
Detalles: Finaliza el programa.
*/
void salir(string fich,struct estacion x[TAM],unsigned short &num,unsigned short num2)
{
    char ch;
    
    cout << "Deseas guardar los datos? Pulsa 'S' para guardarlos, otra letra para salir.\n";
    cout << "La S es mayuscula, tenlo en cuenta o perderas los datos.\n";
    cin >> ch;

    if (ch=='S')
    {
         guardar (fich, x, num, num2);
    }
    
    cout << "\nEl programa ha finalizado.\n";
    cout << "Consulte datos en su fichero " << fich << ".\n";
}

/*Función: case c
Descripción de la función: Insertar un municipio a continuación del vector (en memoria)
Parámetros: Vector de estructuras x, y num2 (num no hace falta!)
Detalles: error si el municipio ya existe (no se puede cambiar los datos de una observación)
*/
void ins(struct estacion x[TAM],unsigned short &num2)
{
    string mun;
    cout << "Dime el nombre del municipio exactamente, primera letra en mayuscula";
    cout << " y todas sin acentos.\n";
    getline(cin,mun);
    if (buscamu(x,num2,mun)!=-1)
    {
        error();
        cout << "Municipio ya existente.\n";
        cout << "Puede ser que lo acabes de introducir y que no hayas actualizado, ";
        cout << "por lo que no te aparece al pulsar b.\n";
    }
    else
    {
        insertar (mun, x, num2);
        
        cout << "Si quieres que calcule bien el resto de opciones";
        cout << " tienes que pulsar la opcion d para actualizar los datos.\n";
    }
}

/*Función: case h
Descripción de la función: Modificar los litros recogidos en un municipio
Parámetros: Array de estaciones, numero relleno, nombre del fichero string fich
Detalles: Pide el nombre del municipio, lo busca en el vector y a continuación
guarda en el campo litros lo que vaya introduciendo el usuario. Luego pregunta si desea guardarlo.
En caso afirmativo llama a una función para que reescriba el fichero entero hasta num.
En caso negativo vuelve al menu.
*/
void modificar (struct estacion x[TAM],unsigned short num, string fich)
{
     string mun;
     int pos;
     unsigned short i;
     char ch;
     
     cout << "La modificacion se actualiza automaticamente, es decir, ";
     cout << "no hace falta que pulses la opcion d para que se guarde en el fichero.\n";
     cout << "El programa lo hace directamente.\n";
     
     cout << "Introduce ahora el nombre del municipio: ";
     getline (cin,mun);
     if ((pos=buscamu(x,num,mun))==-1)
     {
         error();
         cout << "Municipio no existente. Pulsa la opcion c. para insertar una nueva estacion.\n";
     }
     else
     {
         cout << "Introduce ahora los litros en cada una de las ultimas doce horas.\n";
         for (i=0;i<LIT;i++)
         {
             cin >> x[pos].litros[i];
         }
         cout << "Deseas actualizar esta modificacion en tu fichero?";
         cout << " Pulsa 'S' para guardar, otra letra";
         cout << " en caso contrario.\nLa S es mayuscula, tenlo en cuenta o";
         cout << " perderas los datos introducidos.\n";
         cin >> ch;
         cin.ignore(TAM,'\n');
         if (ch=='S')
         {
             reemplazar(x,num,fich);
         }
         else
         {
             cout << "Datos no cargados. Se reinicia el menu.\n";
         }
     }
}

/*Función: Reescribir fichero
Descripción de la función: Reescribe el fichero hasta num con la modificacion de litros recogidos hecha.
Parámetros: Vector de estructuras x, num y nombre del fichero
Detalles: no actualiza las estaciones añadidas en c.
*/
void reemplazar (struct estacion x[TAM],unsigned short num, string fich)
{
       unsigned short i, j;
       ofstream g;
       
       g.open(fich.c_str());
       if (!g)
       {
          cout << "Error.\n";
       }
       else
       {
           for (i=0; i<num; i++)
           {
               g<<x[i].cod<< "\t";
               g<<x[i].mun<< "\n";
               for (j=0; j<LIT-1; j++)
               {
                   g<<x[i].litros[j]<<"\t";
               }
               g << x[i].litros[j] << endl;
           }
           g.close();
           cout << "Esta modificacion ha sido actualizada en el fichero, ";
           cout << "pero no las estaciones que hayas anyadido en c.\n";
       }
}



/******************************************************************************/



//Función principal
int main()
{
    
    
    /********************************************************/
    ////////Declaración de variables/////////
    
    //Array de estructuras con delimitadores num y num2   
    unsigned short num;//nºestaciones original
    unsigned short num2;//nºestaciones tras las modificaciones
    struct estacion x [TAM];//array de estructuras estacion
    
    //conector fich de los ficheros lógicos que aparecen en las funciones
    //(nombre del archivo) con el físico
    string fich;
    
    //Carácter marcador de menú
    char op;
    
    
    
    /********************************************************/
    /*Inicio del programa*/
    inicio(fich,num,num2,x);
    
    if (num==0)
    {
       cout << "No se encuentran datos. Fin del programa.\n";
       system ("Pause");
    }
    else
    {
        cout << "Se van a presentar las precipitaciones guardadas en el fichero.\n\n";
        system ("Pause");
        escribir(x, num);
        
        do
        {//Si se quisiese que al insertar un municipio sin guardarlo, funcionasen
         //el resto de opciones, habría q pasar simplemente num2 en lugar de num.
           menu(op);  
           switch (op)
           {
               case 'a'://buscar
                    {
                        buscar(x,num);
                        break;
                    }
               case 'b'://visualizar
                    {
                        escribir (x,num);
                        break;
                    }
               case 'c'://insertar
                    {
                        ins(x,num2);
                        break;
                    }
               case 'd'://actualizar
                    {
                        guardar (fich, x, num, num2);
                        break;
                    }
               case 'e'://maxminmed municipio/provincia
                    {
                        munprov(x,num);
                        break;
                    }
               case 'f'://maxminmed horas provincia
                    {
                        horas(x,num);
                        break;
                    }
               case 'g'://maxminmed comunidad
                    {
                        comval(x,num);
                        break;
                    }
               case 'h'://modificar
                    {
                        modificar (x,num, fich);
                        break;    
                    }
               case 'i'://limpiar
                    {
                        system("cls");
                        break;    
                    }

               case 'j'://salir
                    {
                        salir (fich,x,num,num2);
                        break;
                    }
               default:
                    {
                        error();
                        break;
                    }
               }
               
               if (op!='i')
               {
                   cout << endl;
                   system ("Pause");
                   cout << endl;
               }
            }
            while (op!='j');
    }
    return 0;
}