Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
Romani - Funzioni.c

Funzioni.c

Caricato da: Poggi Marco
Scarica il programma completo

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include "funzioni.h"
  5.  
  6. void creaCella(Cella *nodo, int valore, const char *cifraRomana)
  7. {
  8.         nodo->simbolo=(char *) malloc(sizeof(char) * 5);
  9.         strcpy(nodo->simbolo, cifraRomana);
  10.         nodo->valore=valore;
  11. }
  12.  
  13. void distruggiCella(Cella *nodo)
  14. {
  15.         free(nodo->simbolo);
  16.         nodo->valore=0;
  17. }
  18.  
  19. int domanda(const char *messaggio, int lInferiore, int lSuperiore)
  20. {
  21.         int esito=0;
  22.         char numero[90]="";
  23.         do
  24.         {
  25.                 printf("\n%s", messaggio);
  26.                 gets(numero);
  27.                 esito=atoi(numero);
  28.                 if (esito < lInferiore)
  29.                 {
  30.                         printf("Inserire un valore maggiore di %d\n", lInferiore);
  31.                         continue;
  32.                 }
  33.                 if(esito > lSuperiore)
  34.                 {
  35.                         printf("Inserire un valore minore di %d\n", lSuperiore);
  36.                         continue;
  37.                 }
  38.                 break;
  39.         } while (1);
  40.         return esito;
  41. }
  42.  
  43. void inizializza(TVettore *registro)
  44. {
  45.         registro->dimensione=30;
  46.         registro->valori=(Cella *) malloc(sizeof(Cella) * registro->dimensione);
  47.         creaCella(&registro->valori[0], 3000, "MMM");
  48.         creaCella(&registro->valori[1], 2000, "MM");
  49.         creaCella(&registro->valori[2], 1000, "M");
  50.         creaCella(&registro->valori[3], 900, "CM");
  51.         creaCella(&registro->valori[4], 800, "DCCC");
  52.         creaCella(&registro->valori[5], 700, "DCC");
  53.         creaCella(&registro->valori[6], 600, "DC");
  54.         creaCella(&registro->valori[7], 500, "D");
  55.         creaCella(&registro->valori[8], 400, "CD");
  56.         creaCella(&registro->valori[9], 300, "CCC");
  57.         creaCella(&registro->valori[10], 200, "CC");
  58.         creaCella(&registro->valori[11], 100, "C");
  59.         creaCella(&registro->valori[12], 90, "XC");
  60.         creaCella(&registro->valori[13], 80, "LXXX");
  61.         creaCella(&registro->valori[14], 70, "LXX");
  62.         creaCella(&registro->valori[15], 60, "LX");
  63.         creaCella(&registro->valori[16], 50, "L");
  64.         creaCella(&registro->valori[17], 40, "XL");
  65.         creaCella(&registro->valori[18], 30, "XXX");
  66.         creaCella(&registro->valori[19], 20, "XX");
  67.         creaCella(&registro->valori[20], 10, "X");
  68.         creaCella(&registro->valori[21], 9, "IX");
  69.         creaCella(&registro->valori[22], 8, "VIII");
  70.         creaCella(&registro->valori[23], 7, "VII");
  71.         creaCella(&registro->valori[24], 6, "VI");
  72.         creaCella(&registro->valori[25], 5, "V");
  73.         creaCella(&registro->valori[26], 4, "IV");
  74.         creaCella(&registro->valori[27], 3, "III");
  75.         creaCella(&registro->valori[28], 2, "II");
  76.         creaCella(&registro->valori[29], 1, "I");
  77. }
  78.  
  79. void distruggiVettore(TVettore *registro)
  80. {
  81.         int i;
  82.         for (i=0; i<registro->dimensione; i++)
  83.         {
  84.                    distruggiCella(&registro->valori[i]);       
  85.         }
  86.         registro->dimensione=0;
  87.         free(registro);
  88. }
  89.  
  90. void stampaCifreRomane(TVettore registro)
  91. {
  92.         int i;
  93.         i=0;
  94.         printf("\nStampa delle cifre romane: \n\n");
  95.         while (i < registro.dimensione)
  96.         {
  97.                 printf("%3d -> valore: %4d simbolo: %4s\n", i+1, registro.valori[i].valore, registro.valori[i].simbolo);
  98.                 i++;
  99.         }
  100. }
  101.  
  102. void ciclo(TVettore registro)
  103. {
  104.         int arabo=0;
  105.         char romano[30]="", risposta='\0';
  106.         do
  107.         {
  108.                 arabo=domanda("Cifra da convertire ? ", 1, 3999);
  109.                 convertiInRomano(arabo, romano, registro);
  110.                 printf("%d in cifre romane: %s", arabo, romano);
  111.                 risposta=chiediUscita("\nContinuo <s / n> ? ");
  112.                 printf("--------------------------------------------------------------------------\n");
  113.         } while ((risposta == 's') || (risposta == 'S'));
  114. }
  115.  
  116. char chiediUscita(const char *messaggio)
  117. {
  118.         printf("\n%s", messaggio);
  119.         char risposta[90]="";
  120.         gets(risposta);
  121.         if (strlen(risposta) >= 1)
  122.                 return risposta[0];
  123.         else
  124.         {
  125.                 return '\0';
  126.         }
  127. }
  128.  
  129. void convertiInRomano(int arabo, char *romano, TVettore registro)
  130. {
  131.         if (romano==NULL)
  132.                 return;
  133.         strcpy(romano, "");
  134.         int i,differenza;
  135.         for (i=0; i<registro.dimensione; i++)
  136.         {
  137.                 differenza=arabo - registro.valori[i].valore;
  138.                 if (differenza >= 0)
  139.                 {
  140.                         strcat(romano, registro.valori[i].simbolo);
  141.                         arabo=differenza;
  142.                 }
  143.         }
  144. }