[C] Variabili enum ed errore di assegnazione

[Lotti]

ho fatto un programmino che date 5 carte da poker, ti dice il punteggio (coppia, doppiacoppia, tris, full, colore, etc..) utilizzando degli enum per rendere il codice più comprensibile (e più facile da programmare).

risultato? per certi punteggi (tris, full e doppiacoppia) il valore dell'enum viene modificato (dal compilatore?) al passaggio dei parametri e mi stampa sempre coppia in quei 3 casi. gli altri punteggi funzionano bene.

posto il codice per farvi vedere l'inghippo

typedef enum poker_score{zero=0, coppia=1, doppiacoppia=2, tris=3, scalan=4, color=5, full=6, poker=7, scalac=8, scalar=9} poker_score;

poker_score check_hand(poker_hand *hand)
{
    int i, j, seme[4], counter[13], coppia=0, tris=0, poker=0;
    for(j=0;j<4;j++) seme[j]=0;
        for(j=0;j<5;j++)
            switch (hand->card[j].seme)
            {
                case C: seme[0]++; break;
                case Q: seme[1]++; break;
                case F: seme[2]++; break;
                case P: seme[3]++; break;
            }

    if (seme[0]==5 || seme[1]==5 || seme[2]==5 || seme[3]==5)
    {
        if((hand->card[0].valore+1==hand->card[1].valore || hand->card[0].valore+12==hand->card[4].valore) &&
            hand->card[1].valore+1==hand->card[2].valore && hand->card[2].valore+1==hand->card[3].valore &&
            hand->card[3].valore+1==hand->card[4].valore)
        {
            if (hand->card[0].valore==v1 && hand->card[4].valore==vK) return scalar;
            else return scalac;
        }
        else
        return color;
    }
    else if((hand->card[0].valore+1==hand->card[1].valore || hand->card[0].valore+12==hand->card[4].valore) &&
            hand->card[1].valore+1==hand->card[2].valore && hand->card[2].valore+1==hand->card[3].valore &&
            hand->card[3].valore+1==hand->card[4].valore) return scalan;
    else
    {
        for(i=0;i<13;i++) counter[i]=0;
        for(i=0;i<5;i++) counter[hand->card[i].valore]++;
        for(i=0;i<13;i++)
        {
            if (counter[i]>=2 && counter[i]<=4)
            {
                for(j=0;j<4;j++) seme[j]=0;
                for(j=0;j<5;j++)
                    if (hand->card[j].valore==i)
                        switch (hand->card[j].seme)
                        {
                            case C: seme[0]++; break;
                            case Q: seme[1]++; break;
                            case F: seme[2]++; break;
                            case P: seme[3]++; break;
                        }
                if(seme[0]<=1 && seme[1]<=1 && seme[2]<=1 && seme[3]<=1)
                switch(counter[i])
                {
                    case 2: coppia++; break;
                    case 3: tris++; break;
                    case 4: poker++; break;
                }
            }
        }
        if (poker) return poker;
        else if (coppia && tris) return full;
        else if (tris) return tris;
        else if (coppia==2) return doppiacoppia;
        else if (coppia) return coppia;
        else return zero;
    }
}

void print_score(poker_score score)
{
    printf("Punteggio: ");
    if (score==zero) printf("Zero");
    else if(score==coppia) printf("Coppia");
    else if (score==doppiacoppia) printf("DoppiaCoppia");
    else if (score==tris) printf("Tris");
    else if (score==scalan) printf("Scala");
    else if (score==color) printf("Colore");
    else if (score==full) printf("Full");
    else if (score==poker) printf("Poker");
    else if (score==scalac) printf("Scala Colore");
    else if (score==scalar) printf("Scala Reale");
    printf("\n");
}

chiamata di stampa punteggio: print_score(check_hand(&hand));

se metto dei printf prima del return nella sequenza di if che termina la funzione che calcola il punteggio, viene stampato il valore corretto (cioè quella mega if funziona).

se metto dei printf di score nella funzione che stampa il punteggio, la if funziona perfettamente perchè lo score PER NON SI SA QUALE MOTIVO viene impostato a 1 anche per i valori tris, poker e doppiacoppia. gli altri funzionano bene.

se alla funzione che calcola il punteggio invece di scrivere return "enum", scrivo return "numero" tutto funziona. maledetti enum!

[oregon]

Ma nel caso che ti ho evidenziato, cosa restituisce la funzione ?

Originariamente inviato da Lotti

poker_score check_hand(poker_hand *hand)
{
    int i, j, seme[4], counter[13], coppia=0, tris=0, poker=0;
    for(j=0;j<4;j++) seme[j]=0;
        for(j=0;j<5;j++)
            switch (hand->card[j].seme)
            {
                case C: seme[0]++; break;
                case Q: seme[1]++; break;
                case F: seme[2]++; break;
                case P: seme[3]++; break;
            }

    if (seme[0]==5 || seme[1]==5 || seme[2]==5 || seme[3]==5)
    {
        if((hand->card[0].valore+1==hand->card[1].valore || hand->card[0].valore+12==hand->card[4].valore) &&
            hand->card[1].valore+1==hand->card[2].valore && hand->card[2].valore+1==hand->card[3].valore &&
            hand->card[3].valore+1==hand->card[4].valore)
        {
            if (hand->card[0].valore==v1 && hand->card[4].valore==vK) return scalar;
            else return scalac;
        }
        else
        return color;
    }
    else if((hand->card[0].valore+1==hand->card[1].valore || hand->card[0].valore+12==hand->card[4].valore) &&
            hand->card[1].valore+1==hand->card[2].valore && hand->card[2].valore+1==hand->card[3].valore &&
            hand->card[3].valore+1==hand->card[4].valore) return scalan;
    else
    {
        for(i=0;i<13;i++) counter[i]=0;
        for(i=0;i<5;i++) counter[hand->card[i].valore]++;
        for(i=0;i<13;i++)
        {
            if (counter[i]>=2 && counter[i]<=4)
            {
                for(j=0;j<4;j++) seme[j]=0;
                for(j=0;j<5;j++)
                    if (hand->card[j].valore==i)
                        switch (hand->card[j].seme)
                        {
                            case C: seme[0]++; break;
                            case Q: seme[1]++; break;
                            case F: seme[2]++; break;
                            case P: seme[3]++; break;
                        }
                if(seme[0]<=1 && seme[1]<=1 && seme[2]<=1 && seme[3]<=1)
                switch(counter[i])
                {
                    case 2: coppia++; break;
                    case 3: tris++; break;
                    case 4: poker++; break;
                }
            }
        }
        if (poker) return poker;
        else if (coppia && tris) return full;
        else if (tris) return tris;
        else if (coppia==2) return doppiacoppia;
        else if (coppia) return coppia;
        else return zero;
    }

    // In questo caso, cosa restituisce questa funzione?
}

[Lotti]

quel caso è coperto dall'else nell'else. ovvero, l'if grande ha un else. dentro a quell'else, c'è un altro if seguito da ELSE. quindi i return sono giusti, altrimenti avrei avuto dei warning in compilazione.

cmq farò una prova ma dubito cambi qualcosa.

[oregon]

Cosi' come e' scritto, non si capisce facilmente perche' i blocchi if ... else non sono affatto chiaramente indentati ...

In ogni caso, mancano alcune dichiarazioni (ad esempio il tipo poker_hand ...) e per fare un controllo veloce (copia incolla del codice) sono essenziali ...

[Lotti]

typedef enum card_suit{C=0, Q=1, F=2, P=3} card_suit;

typedef enum card_value{v1=0, v2=1, v3=2, v4=3, v5=4, v6=5, v7=6, v8=7, v9=8, v10=9, vJ=10, vQ=11, vK=12} card_value;

typedef struct poker_card
{
    card_suit seme;
    card_value valore;
} poker_card;

typedef struct poker_hand
{
    poker_card card[5];
} poker_hand;

ora che hai tutti i typedef scoprirai che non cambia nulla

anche se metto "return zero;" alla fine della funzione che calcola il punteggio, non cambia nulla, il bug rimane lo stesso.

[MacApp]

A prima vista... nella funzione "poker_score check_hand(poker_hand *hand)" le variabili "int coppia=0, tris=0, poker=0" nascondono l'enum poker_score;

[oregon]

ora che hai tutti i typedef scoprirai che non cambia nulla

Non voglio "scoprire" nulla ... vorrei solamente darti una mano e per farlo mi servono tutti i "pezzi" per avere un'idea completa del problema ...

In ogni caso, ho notato che, ad esempio per il poker, utilizzi una variabile all'interno della funzione, che si chiama

poker

esattamente come per il nome usato all'interno dell'enum. Ovviamente questo e' sbagliato perche' con

return poker;

restituisci il valore della variabile e non il valore dell'enum.

Quindi, non sono gli enum a fare scherzi, ma se tu a fare scherzi agli enum ...

[Lotti]

mmm giusto, avete ragione. maledetta programmazione a oggetti tornare indietro è veramente faticoso.. devi stare attento a mille cose!

grazie per l'impegno