Eserciziario C++ Lezione 17

/*
Preparare con il blocco note un file studenti.txt contenente i
nominativi della vostra classe nella forma cognome-nome (Rossi-Mario),
un nominativo per riga. Il programma parte presentando questo menu:

1 - Sorteggio
2 - Elenco rimanenti
3 - Elenco di chi é giá stato interrogato
4 - Reset
99 - fine

Scegliendo 1
Il programma chiede quanti nominativi devono essere estratti e procede
all'estrazione listando i nominativi; questi saranno tolti
dall'elenco di estrazione. All'uscita il programma aggiornerá
i dati sui file in modo che alla prossima ripartenza si potrá
procedere con i rimanenti.

Scegliendo 2
Sará presentata una lista di chi deve ancora essere interrogato.

Scegliendo 3
Sará presentata una lista di chi é gia stato interrogato

Scegliendo 4
I dati su disco (e in RAM) saranno aggiornati in modo tale
che si riparta con le estrazioni con l'elenco degli
alunni al completo.
*/

#include <iostream>
#include <fstream>
#include <ctime>


using namespace std;

int leggi_intero(int min, int max, string messaggio="")
{
  int letto=0;
  do
  {
     cout<<messaggio<<" ("<<min<<" - "<<max<<"): ";
     cin>>letto;

     if (letto<min || letto>max)
       cout<<endl<<"Valore non nell'intervallo consentito ("<<min<<" - "<<max<<")\n";
  } while ( letto<min || letto>max );

  return letto;
}

//presenta un elenco di scelte numerate e gestisce la scelta dell'utente
//restituisce o la scelta o -1 se l'utente ha annullato

int menu(string voci_menu[], int quante_voci)
{
    for(int i=0; i<quante_voci; i++)
      cout << i+1 << " - " << voci_menu[i] << endl;

    cout << quante_voci + 1 << " - STOP\n";

    return leggi_intero(1, quante_voci+1,   "Scegli una voce");
}


//testa esistenza file
bool esiste_file(string path_file)
{
  bool esiste=false;

  ifstream f(path_file);
  if (f)
  {
    f.close(); f.clear();
    esiste = true;
  }

  return esiste;
}







int carica_array_da_file(string path_file, string v[], int capienza_array)
{

  if (!esiste_file(path_file)) return 0;

  int conta=0;
  ifstream leggi(path_file);

  while (conta<capienza_array && getline(leggi, v[conta])) conta++;

  leggi.close(); leggi.clear();

  return conta;

}

//restituisce -1 se il file non esiste, altrimenti il numero di righe copiate
int copia_file(string path_sorgente, string path_destinazione)
{
  if (!esiste_file(path_sorgente)) return -1;

  ifstream sorgente(path_sorgente);
  ofstream destinazione(path_destinazione);

  if (!destinazione)
  {
    sorgente.close(); sorgente.clear();
    return -2;
  }

  string riga;
  int copiate=0;

  while ( getline(sorgente, riga) )
  {
    //cout << riga
    destinazione << riga << endl;
    copiate++;
  }

  sorgente.close(); sorgente.clear();
  destinazione.close(); destinazione.clear();
  return copiate;
}

void sorteggia(int quanti_da_interrogare, int &alunni_rimasti,
               string alunni[], string interrogati[])
{
  for (int i=0; i<quanti_da_interrogare; i++)
  {
    int interrogato = rand()%alunni_rimasti;
    interrogati[i] = alunni[interrogato];
    //swap(alunni[interrogato], alunni[alunni_rimasti-1]);
    alunni[interrogato] = alunni[alunni_rimasti-1];
    alunni_rimasti--;
  }
}

void stampa_array_stringhe(string v[], int quanti,
                    bool a_capo=true, char c='*') //parametri di default
{
  for (int i=0; i<quanti; i++)
  {
    cout << v[i];
    if (a_capo) cout<<endl; else cout << " ";
  }

  cout << string(30, c) << endl;
}

void salva_array_su_file(string v[], int quanti_da_salvare, string path_file)
{
  ofstream scrivi(path_file);

  for (int i=0; i<quanti_da_salvare; i++) scrivi << v[i] << endl;

  scrivi.close(); scrivi.clear();
}

int cerca_stringa_in_vettore(string cercata, string v[], int num_ele)
{
  for (int i=0; i<num_ele; i++)
    if (cercata==v[i]) return i;

  return -1;
}

void stampa_gia_interrogati(string path_file_backup, string alunni[], int alunni_rimasti)
{
  ifstream leggi(path_file_backup);

  //leggo un nominativo lo cerco in alunni[] e se non lo trovo lo stampo
  string alunno ="";

  while ( getline(leggi, alunno) )
    if (cerca_stringa_in_vettore(alunno, alunni, alunni_rimasti) < 0) //non trovato
      cout << alunno << endl;

   leggi.close(); leggi.clear();
 }



int main()
{
  srand(time(0));

  //IDEA professionale (non la implemento, solo come suggerimento)
  //i nomi dei file e altri parametri potrebbero essere letti da un file di
  //servizio in modo che li si possa facilmente cambiare senza toccare il programma

  string path_file_alunni = "alunni.txt";
  string path_file_backup = "alunni_backup.txt";

  //per dare la possibilitá di resettare con elenco alunni al completo
  //creo una copia di backup dell'elenco degli alunni
  //questa operazione va fatta solo la prima volta che si lancia il programma
  if (!esiste_file(path_file_backup))
    copia_file(path_file_alunni, path_file_backup);

  //leggo gli interrogandi in un array e li conto
  const int MAX_ALUNNI = 40;
  string alunni[MAX_ALUNNI];
  string interrogati[MAX_ALUNNI];
  int quanti_da_interrogare = 0;

  int alunni_rimasti = carica_array_da_file(path_file_alunni, alunni, MAX_ALUNNI);

  //preparo le voci come da testo dell'esercizio
  string voci_menu[] {"Sorteggio",
                      "Elenco rimanenti",
                      "Elenco di chi e' gia' stato interrogato",
                      "Reset dello stesso elenco (nuovo turno interrogazioni"};
  int num_voci_menu = 4;

  int scelta=0;

  do
  {

    scelta = menu(voci_menu, 4);

    switch (scelta)
    {
      case 1: //sorteggio interrogati
        if (alunni_rimasti==0)
          cout << "Nessun alunno rimasto da interrogare\n";
        else
        {
          quanti_da_interrogare = leggi_intero(1, alunni_rimasti, "Quanti da interrogare");
          sorteggia(quanti_da_interrogare, alunni_rimasti, alunni, interrogati);
          stampa_array_stringhe(interrogati, quanti_da_interrogare);

          //aggiorno su disco gli alunni rimasti da interrogare
          salva_array_su_file(alunni, alunni_rimasti, path_file_alunni);
        }
      break;

      case 2: //elenco rimasti
        stampa_array_stringhe(alunni,alunni_rimasti);
      break;

      case 3: //chi é giá stato interrogato
        //il file di backup li contiene tutti
        //alunni[] contiene quelli ancora da interrogare
        stampa_gia_interrogati(path_file_backup, alunni, alunni_rimasti);
      break;

      case 4: //reset per nuovo giro interrogazioni
      {
        string conferma="NO";
        cout << "Reset dello stesso, confermi (scrivi SI) -> ";
        cin >> conferma;

        if (conferma=="SI")
        {
          //ripristino file alunni
          alunni_rimasti = copia_file(path_file_backup, path_file_alunni);

          //ricarico elenco
          carica_array_da_file(path_file_alunni, alunni, MAX_ALUNNI);

        }


      }
      break;

      default:

       break;
    }

    system("pause"); system("cls");
  }
  while (scelta != num_voci_menu+1 );

  return 0;
}