Lezione 5a - strutture dati

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

enum Seme{
    cuori = 0,
    quadri = 1,
    fiori = 2,
    picche = 3,
};

//enumerazione per i valori
enum Valori{
    Asso = 1,
    Fante = 11,
    Donna = 12,
    Re = 13,
};


//funzione che stampa la carta
string stampa_carta(int valore, int seme){

        // seme switch block
        string nome_seme; // dichiarazione variabile nome del seme

        switch(seme){
            case 0:
                nome_seme = "cuori";
                break;
            case 1:
                nome_seme = "quadri";
                break;
            case 2:
                nome_seme = "fiori";
                break;
            case 3:
                nome_seme = "picche";
                break;
            default:
                nome_seme = "seme non definito";
        }

        // valore switch block
        string nome_valore; // dichiarazione variable nome delvalore

        switch(valore){
            case 1:
                nome_valore = "Asso";
                break;
            case 11:
                nome_valore = "Fante";
                break;
            case 12:
                nome_valore = "Donna";
                break;
            case 13:
                nome_valore = "Re";
                break;
            default:
                // conversione numero a stringa
                char buffer[33];
                itoa(valore, buffer, 10);
                nome_valore = buffer;
        }

        // costruiamo ora per intero il nome della carta
        string nome_carta = nome_valore + " di " + nome_seme;

        return nome_carta;
}





// ora abbiamo dei prototipi per amministrare le carte.
// delle enumerationi che ci aiutano a scrivere in modo umano
// delle carte rappresentate da due interi.

// C++ offre classi e strutture per estendere la manipolazione dei tipi di base
// ora abbiamo i due interi che sono in libertà e indipendenti tra loro
// ma non esiste una carta con un valore senza un seme o un seme senza un valore.
// dunque possiamo unire i due interi rappresentanti la carta in una struttura dati
// una struttura dati è semplicemente un composto di dati primari
// potrebbe essere una stringa e un intero, più stringhe, più interi, ecc ecc.

// la struttura adibita alla carta chiamata "Carta" ora conterra 2 membri.
// un intero che definisce il seme e uno che definisce il valore.
// Nel main si scriverea Carta (nome variabile); poi si procede all'
// inizializazione dei membri.
// (nome variabile).valore = 10;
// (nome seme).seme = quadri (definito come 1 nella enum semi v. sopra)

// è una concezione astratta.
struct Carta{
    int valore;
    int seme;
};

//------------------------------------> vedi esempio alla riga xx

// La struttura sopra richiede ora una dichiarazione (1)
// un inizializzazione (2)
// e se vogliamo una stampa (3)
// nell esempio vediamo già che ci serve una funzione per stampare i valori
// in modo umano (con asso al posto di 1 e il nome del seme)
// e inoltre dobbiamo fare una cosa scomoda, richiamare gli attributi della
// carta singolarmente (con (nome variabile).valore e (nome variabile).seme)
// questo è relativamente scomodo.

// Possiamo invece usare delle funzioni che lo faranno per noi.

// funzione di inizializzazione.
// la funzione prenderà una referenza a una carta esistente.
// l'& nella dichiarazione degli argomenti fa in modo che la variabile sia
// modificata internamente alla funzione, e la variabile si ricordi della
// modifica dopo l'esecuzione della funzione
void inizializza_carta(Carta& carta, int valore, int seme){
    carta.valore = valore; //assegna alla carta di input il valore
    carta.seme = seme; // assegna il seme al membro seme

    // return xxx; > da notare come la funzione non "ritorna" niente, dato che
    // modifica già la nostra carta via referenza
}

// ---------------------------------------> vedi esempio alla riga xx

// per ora ogni volta che dobbiamo stampare la carta con la funzione
// stampa_carta dobbiamo passare i due vaolri separatamente
// ma potremmo definire una funzione che accetta la carta come tale.
string stampa_struct_carta(Carta carta){
    return stampa_carta(carta.valore, carta.seme);
}

// ---------------------------------------> vedi esempio alla riga xx


// Lezione 5a - Strutture
int main()
{
    cout << "------Il mazzo------" << endl;
    // il nostro programma per generare tutte le carte in un mazzo da
    // 52 carte

    // ciclo seme ( da 0 a 3)
    int seme = 0; // dichiariamo una variabile seme
    while(seme <= 3){ // fino a che seme sara minore uguale a tre

        // ciclo valore (da 1 a 13)
        int valore = 1; // dichiarazione e assegnazione del valore iniziale
        while(valore <= 13){ // fino a che la variabile valore non è 13, esegui le istruzioni
                cout << stampa_carta(valore, seme) << endl;
            valore++; // fa aumentare il valore di uno
        }
        seme++; // incrementa il seme
    }

    cout << endl;
    cout << "------Carte singole------" << endl;

    // creare una carta singola con la struttura dati.

    // punto 1: dichiarare il nome variabile
    Carta asso_picche;

    //cout << asso_picche.valore << " di " << asso_picche.seme << endl;
    // 2686728 di 2686916 l'outpud è un valore indefinito, infatti chiamare la
    // dei membri non inizializzati è un errore e si chiama undefined behavior
    // è un errore molto difficile da detettare dato che accade a run time e non
    // a compile time

    // punto 2: inizializzare i membri.
    asso_picche.valore = Asso; //asso definito come 1 nella enum sopra
    asso_picche.seme = picche; //picche definitio come 3 nella enum sopra

    // punto 3: stampare la carta
    // stampa dei valori
    cout << asso_picche.valore << " di " << asso_picche.seme << endl;

    // stampa formattata con i nomi giusti sia del valore che dei semi
    cout << stampa_carta(asso_picche.valore, asso_picche.seme) << endl;

    // definiamo una nuova carta
    Carta re_fiori;

    inizializza_carta(re_fiori, Re, fiori);

    cout << re_fiori.valore << " di " << re_fiori.seme << endl;

    cout << stampa_carta(re_fiori.valore, re_fiori.seme) << endl;

    // definiamo una nuova carta

    Carta donna_cuori;
    inizializza_carta(donna_cuori, Donna, cuori);
    cout << stampa_struct_carta(donna_cuori) << endl;




    return 0;
}





/* OUTPUT
------Il mazzo------
Asso di cuori
2 di cuori
3 di cuori
4 di cuori
5 di cuori
6 di cuori
7 di cuori
8 di cuori
9 di cuori
10 di cuori
Fante di cuori
Donna di cuori
Re di cuori
Asso di quadri
2 di quadri
3 di quadri
4 di quadri
5 di quadri
6 di quadri
7 di quadri
8 di quadri
9 di quadri
10 di quadri
Fante di quadri
Donna di quadri
Re di quadri
Asso di fiori
2 di fiori
3 di fiori
4 di fiori
5 di fiori
6 di fiori
7 di fiori
8 di fiori
9 di fiori
10 di fiori
Fante di fiori
Donna di fiori
Re di fiori
Asso di picche
2 di picche
3 di picche
4 di picche
5 di picche
6 di picche
7 di picche
8 di picche
9 di picche
10 di picche
Fante di picche
Donna di picche
Re di picche

------Carte singole------
1 di 3
Asso di picche
13 di 2
Re di fiori
Donna di cuori
*/