C/C++ - problema menu - PieroTofy.it

02/05/16 20:39

Se vuoi adottare la mia soluzione devi inserire la parte di codice che ti ho scritto subito dopo la scanf("%d",&sel_menu)
Quella che hai scritto dopo menu()

aaa

02/05/16 22:55

AldoBaldo

Personalmente preferisco la soluzione proposta da Lumo. Di solito faccio qualcosa del genere...

#include <stdio.h>
#include <stdlib.h>

// titolo del menu'
const char *kStrTitoloMenu = "OPERAZIONI";

// voci del menu'
const char *kStrVociMenu[] = {
    "Uscita",
    "Addizione",
    "Sottrazione",
    "Moltiplicazione",
    "Divisione"
};

// codici dei comandi
enum {
    kCmnd_Uscita, // sempre 0
    kCmnd_Addizione,
    kCmnd_Sottrazione,
    kCmnd_Moltiplicazione,
    kCmnd_Divisione,
    kTotaleCmnd
};

/*==============================================================================
Verifica che "s" sia una stringa C valida che rappresenta un intero positivo.
==============================================================================*/

int Numero( const char *s ) {
    int esito = 0;

    if( s != NULL ) {
        if( *s != 'Personalmente preferisco la soluzione proposta da Lumo. Di solito faccio qualcosa del genere...



#include <stdio.h>
#include <stdlib.h>

// titolo del menu'
const char *kStrTitoloMenu = "OPERAZIONI";

// voci del menu'
const char *kStrVociMenu[] = {
    "Uscita",
    "Addizione",
    "Sottrazione",
    "Moltiplicazione",
    "Divisione"
};

// codici dei comandi
enum {
    kCmnd_Uscita, // sempre 0
    kCmnd_Addizione,
    kCmnd_Sottrazione,
    kCmnd_Moltiplicazione,
    kCmnd_Divisione,
    kTotaleCmnd
};

/*==============================================================================
Verifica che "s" sia una stringa C valida che rappresenta un intero positivo.
==============================================================================*/

int Numero( const char *s ) {
    int esito = 0;

    if( s != NULL ) {
        if( *s != '{parsed_message}' ) {
            for( esito=1; *s!='{parsed_message}'; ++s ) {
                if( *s < '0' || *s > '9' ) {
                    esito = 0;
                    break;
                }
            }
        }
    }

    return esito;
}

/*==============================================================================
Presenta un menu' dal titolo "titolo", ricavato dall'array di puntatori a
stringa "voci". La prima delle voci deve rappresentare quella da impiegare per
uscire dal menu'.
La funzione continua a chiedere un nuovo inserimento fintanto che l'utente non
esprime una scelta valida, ovvero un numero intero compreso tra 0 ("uscita")
e la quantita' delle altre voci presenti nel menu'.
In uscita, il valore restituito dalla funzione rappresenta SEMPRE una scelta
valida da parte dell'utente, A MENO CHE sia stato passato un array "voci" NULL
o con un primo elemento costituito da una stringa vuota (""). In quei casi
(cioe' mai, se "voci" e' stato predisposto adeguatamente), la funzione
restituisce -1 .
==============================================================================*/

int Menu( const char *titolo, const char **voci, int nVoci ) {
    int pp = 1; // pp = primo passaggio
    int i, l, scelta = -1;
    const int kDimBuff = 16;
    char buff[kDimBuff];

    if( voci != NULL ) {
        if( *voci != NULL ) {
            // visualizza il titolo
            printf( "\n   %s\n ", titolo );
            for( i=0; i<40; ++i ) printf( "=" );

            // visualizza le altre voci
            for( i=1; i<nVoci; ++i )
                printf( "\n  %2d. %s", i, voci[i] );

            // visualizza l'opzione di uscita
            printf( "\n  %2d. %s\n\n", 0, voci[0] );

            while( scelta < 0 || scelta >= nVoci ) {
                if( pp ) {
                    printf( " Scegli una voce dal menu: " );
                    pp = 0;
                }
                else {
                    printf( " Scelta non valida, riprova: " );
                }

                fgets( buff, kDimBuff, stdin );

                // lunghezza della stringa
                for( l=0; buff[l]!='{parsed_message}'; ++l );

                if( l != 0 ) {
                    // elimina il new line a fine riga (se c'e')
                    if( buff[l-1] == '\n' ) buff[--l] = '{parsed_message}';
                    // rileva la scelta dell'utente
                    if( Numero(buff) ) scelta = atoi( buff );
                }
            }

            printf( "\n" );
        }
    }

    return scelta;
}

int main() {
    int sel_menu;

    do {
        sel_menu = Menu( kStrTitoloMenu, kStrVociMenu, kTotaleCmnd );

        switch( sel_menu ) {
            case kCmnd_Addizione:
                printf( " Addizione\n" );
                break;
            case kCmnd_Sottrazione:
                printf( " Sottrazione\n" );
                break;
            case kCmnd_Moltiplicazione:
                printf( " Moltiplicazione\n" );
                break;
            case kCmnd_Divisione:
                printf( " Divisione\n" );
                break;
            default: ;
        }
    } while( sel_menu != kCmnd_Uscita );

    return 0;
}' ) {
            for( esito=1; *s!='Personalmente preferisco la soluzione proposta da Lumo. Di solito faccio qualcosa del genere...



#include <stdio.h>
#include <stdlib.h>

// titolo del menu'
const char *kStrTitoloMenu = "OPERAZIONI";

// voci del menu'
const char *kStrVociMenu[] = {
    "Uscita",
    "Addizione",
    "Sottrazione",
    "Moltiplicazione",
    "Divisione"
};

// codici dei comandi
enum {
    kCmnd_Uscita, // sempre 0
    kCmnd_Addizione,
    kCmnd_Sottrazione,
    kCmnd_Moltiplicazione,
    kCmnd_Divisione,
    kTotaleCmnd
};

/*==============================================================================
Verifica che "s" sia una stringa C valida che rappresenta un intero positivo.
==============================================================================*/

int Numero( const char *s ) {
    int esito = 0;

    if( s != NULL ) {
        if( *s != '{parsed_message}' ) {
            for( esito=1; *s!='{parsed_message}'; ++s ) {
                if( *s < '0' || *s > '9' ) {
                    esito = 0;
                    break;
                }
            }
        }
    }

    return esito;
}

/*==============================================================================
Presenta un menu' dal titolo "titolo", ricavato dall'array di puntatori a
stringa "voci". La prima delle voci deve rappresentare quella da impiegare per
uscire dal menu'.
La funzione continua a chiedere un nuovo inserimento fintanto che l'utente non
esprime una scelta valida, ovvero un numero intero compreso tra 0 ("uscita")
e la quantita' delle altre voci presenti nel menu'.
In uscita, il valore restituito dalla funzione rappresenta SEMPRE una scelta
valida da parte dell'utente, A MENO CHE sia stato passato un array "voci" NULL
o con un primo elemento costituito da una stringa vuota (""). In quei casi
(cioe' mai, se "voci" e' stato predisposto adeguatamente), la funzione
restituisce -1 .
==============================================================================*/

int Menu( const char *titolo, const char **voci, int nVoci ) {
    int pp = 1; // pp = primo passaggio
    int i, l, scelta = -1;
    const int kDimBuff = 16;
    char buff[kDimBuff];

    if( voci != NULL ) {
        if( *voci != NULL ) {
            // visualizza il titolo
            printf( "\n   %s\n ", titolo );
            for( i=0; i<40; ++i ) printf( "=" );

            // visualizza le altre voci
            for( i=1; i<nVoci; ++i )
                printf( "\n  %2d. %s", i, voci[i] );

            // visualizza l'opzione di uscita
            printf( "\n  %2d. %s\n\n", 0, voci[0] );

            while( scelta < 0 || scelta >= nVoci ) {
                if( pp ) {
                    printf( " Scegli una voce dal menu: " );
                    pp = 0;
                }
                else {
                    printf( " Scelta non valida, riprova: " );
                }

                fgets( buff, kDimBuff, stdin );

                // lunghezza della stringa
                for( l=0; buff[l]!='{parsed_message}'; ++l );

                if( l != 0 ) {
                    // elimina il new line a fine riga (se c'e')
                    if( buff[l-1] == '\n' ) buff[--l] = '{parsed_message}';
                    // rileva la scelta dell'utente
                    if( Numero(buff) ) scelta = atoi( buff );
                }
            }

            printf( "\n" );
        }
    }

    return scelta;
}

int main() {
    int sel_menu;

    do {
        sel_menu = Menu( kStrTitoloMenu, kStrVociMenu, kTotaleCmnd );

        switch( sel_menu ) {
            case kCmnd_Addizione:
                printf( " Addizione\n" );
                break;
            case kCmnd_Sottrazione:
                printf( " Sottrazione\n" );
                break;
            case kCmnd_Moltiplicazione:
                printf( " Moltiplicazione\n" );
                break;
            case kCmnd_Divisione:
                printf( " Divisione\n" );
                break;
            default: ;
        }
    } while( sel_menu != kCmnd_Uscita );

    return 0;
}'; ++s ) {
                if( *s < '0' || *s > '9' ) {
                    esito = 0;
                    break;
                }
            }
        }
    }

    return esito;
}

/*==============================================================================
Presenta un menu' dal titolo "titolo", ricavato dall'array di puntatori a
stringa "voci". La prima delle voci deve rappresentare quella da impiegare per
uscire dal menu'.
La funzione continua a chiedere un nuovo inserimento fintanto che l'utente non
esprime una scelta valida, ovvero un numero intero compreso tra 0 ("uscita")
e la quantita' delle altre voci presenti nel menu'.
In uscita, il valore restituito dalla funzione rappresenta SEMPRE una scelta
valida da parte dell'utente, A MENO CHE sia stato passato un array "voci" NULL
o con un primo elemento costituito da una stringa vuota (""). In quei casi
(cioe' mai, se "voci" e' stato predisposto adeguatamente), la funzione
restituisce -1 .
==============================================================================*/

int Menu( const char *titolo, const char **voci, int nVoci ) {
    int pp = 1; // pp = primo passaggio
    int i, l, scelta = -1;
    const int kDimBuff = 16;
    char buff[kDimBuff];

    if( voci != NULL ) {
        if( *voci != NULL ) {
            // visualizza il titolo
            printf( "\n   %s\n ", titolo );
            for( i=0; i<40; ++i ) printf( "=" );

            // visualizza le altre voci
            for( i=1; i<nVoci; ++i )
                printf( "\n  %2d. %s", i, voci[i] );

            // visualizza l'opzione di uscita
            printf( "\n  %2d. %s\n\n", 0, voci[0] );

            while( scelta < 0 || scelta >= nVoci ) {
                if( pp ) {
                    printf( " Scegli una voce dal menu: " );
                    pp = 0;
                }
                else {
                    printf( " Scelta non valida, riprova: " );
                }

                fgets( buff, kDimBuff, stdin );

                // lunghezza della stringa
                for( l=0; buff[l]!='Personalmente preferisco la soluzione proposta da Lumo. Di solito faccio qualcosa del genere...



#include <stdio.h>
#include <stdlib.h>

// titolo del menu'
const char *kStrTitoloMenu = "OPERAZIONI";

// voci del menu'
const char *kStrVociMenu[] = {
    "Uscita",
    "Addizione",
    "Sottrazione",
    "Moltiplicazione",
    "Divisione"
};

// codici dei comandi
enum {
    kCmnd_Uscita, // sempre 0
    kCmnd_Addizione,
    kCmnd_Sottrazione,
    kCmnd_Moltiplicazione,
    kCmnd_Divisione,
    kTotaleCmnd
};

/*==============================================================================
Verifica che "s" sia una stringa C valida che rappresenta un intero positivo.
==============================================================================*/

int Numero( const char *s ) {
    int esito = 0;

    if( s != NULL ) {
        if( *s != '{parsed_message}' ) {
            for( esito=1; *s!='{parsed_message}'; ++s ) {
                if( *s < '0' || *s > '9' ) {
                    esito = 0;
                    break;
                }
            }
        }
    }

    return esito;
}

/*==============================================================================
Presenta un menu' dal titolo "titolo", ricavato dall'array di puntatori a
stringa "voci". La prima delle voci deve rappresentare quella da impiegare per
uscire dal menu'.
La funzione continua a chiedere un nuovo inserimento fintanto che l'utente non
esprime una scelta valida, ovvero un numero intero compreso tra 0 ("uscita")
e la quantita' delle altre voci presenti nel menu'.
In uscita, il valore restituito dalla funzione rappresenta SEMPRE una scelta
valida da parte dell'utente, A MENO CHE sia stato passato un array "voci" NULL
o con un primo elemento costituito da una stringa vuota (""). In quei casi
(cioe' mai, se "voci" e' stato predisposto adeguatamente), la funzione
restituisce -1 .
==============================================================================*/

int Menu( const char *titolo, const char **voci, int nVoci ) {
    int pp = 1; // pp = primo passaggio
    int i, l, scelta = -1;
    const int kDimBuff = 16;
    char buff[kDimBuff];

    if( voci != NULL ) {
        if( *voci != NULL ) {
            // visualizza il titolo
            printf( "\n   %s\n ", titolo );
            for( i=0; i<40; ++i ) printf( "=" );

            // visualizza le altre voci
            for( i=1; i<nVoci; ++i )
                printf( "\n  %2d. %s", i, voci[i] );

            // visualizza l'opzione di uscita
            printf( "\n  %2d. %s\n\n", 0, voci[0] );

            while( scelta < 0 || scelta >= nVoci ) {
                if( pp ) {
                    printf( " Scegli una voce dal menu: " );
                    pp = 0;
                }
                else {
                    printf( " Scelta non valida, riprova: " );
                }

                fgets( buff, kDimBuff, stdin );

                // lunghezza della stringa
                for( l=0; buff[l]!='{parsed_message}'; ++l );

                if( l != 0 ) {
                    // elimina il new line a fine riga (se c'e')
                    if( buff[l-1] == '\n' ) buff[--l] = '{parsed_message}';
                    // rileva la scelta dell'utente
                    if( Numero(buff) ) scelta = atoi( buff );
                }
            }

            printf( "\n" );
        }
    }

    return scelta;
}

int main() {
    int sel_menu;

    do {
        sel_menu = Menu( kStrTitoloMenu, kStrVociMenu, kTotaleCmnd );

        switch( sel_menu ) {
            case kCmnd_Addizione:
                printf( " Addizione\n" );
                break;
            case kCmnd_Sottrazione:
                printf( " Sottrazione\n" );
                break;
            case kCmnd_Moltiplicazione:
                printf( " Moltiplicazione\n" );
                break;
            case kCmnd_Divisione:
                printf( " Divisione\n" );
                break;
            default: ;
        }
    } while( sel_menu != kCmnd_Uscita );

    return 0;
}'; ++l );

                if( l != 0 ) {
                    // elimina il new line a fine riga (se c'e')
                    if( buff[l-1] == '\n' ) buff[--l] = 'Personalmente preferisco la soluzione proposta da Lumo. Di solito faccio qualcosa del genere...



#include <stdio.h>
#include <stdlib.h>

// titolo del menu'
const char *kStrTitoloMenu = "OPERAZIONI";

// voci del menu'
const char *kStrVociMenu[] = {
    "Uscita",
    "Addizione",
    "Sottrazione",
    "Moltiplicazione",
    "Divisione"
};

// codici dei comandi
enum {
    kCmnd_Uscita, // sempre 0
    kCmnd_Addizione,
    kCmnd_Sottrazione,
    kCmnd_Moltiplicazione,
    kCmnd_Divisione,
    kTotaleCmnd
};

/*==============================================================================
Verifica che "s" sia una stringa C valida che rappresenta un intero positivo.
==============================================================================*/

int Numero( const char *s ) {
    int esito = 0;

    if( s != NULL ) {
        if( *s != '{parsed_message}' ) {
            for( esito=1; *s!='{parsed_message}'; ++s ) {
                if( *s < '0' || *s > '9' ) {
                    esito = 0;
                    break;
                }
            }
        }
    }

    return esito;
}

/*==============================================================================
Presenta un menu' dal titolo "titolo", ricavato dall'array di puntatori a
stringa "voci". La prima delle voci deve rappresentare quella da impiegare per
uscire dal menu'.
La funzione continua a chiedere un nuovo inserimento fintanto che l'utente non
esprime una scelta valida, ovvero un numero intero compreso tra 0 ("uscita")
e la quantita' delle altre voci presenti nel menu'.
In uscita, il valore restituito dalla funzione rappresenta SEMPRE una scelta
valida da parte dell'utente, A MENO CHE sia stato passato un array "voci" NULL
o con un primo elemento costituito da una stringa vuota (""). In quei casi
(cioe' mai, se "voci" e' stato predisposto adeguatamente), la funzione
restituisce -1 .
==============================================================================*/

int Menu( const char *titolo, const char **voci, int nVoci ) {
    int pp = 1; // pp = primo passaggio
    int i, l, scelta = -1;
    const int kDimBuff = 16;
    char buff[kDimBuff];

    if( voci != NULL ) {
        if( *voci != NULL ) {
            // visualizza il titolo
            printf( "\n   %s\n ", titolo );
            for( i=0; i<40; ++i ) printf( "=" );

            // visualizza le altre voci
            for( i=1; i<nVoci; ++i )
                printf( "\n  %2d. %s", i, voci[i] );

            // visualizza l'opzione di uscita
            printf( "\n  %2d. %s\n\n", 0, voci[0] );

            while( scelta < 0 || scelta >= nVoci ) {
                if( pp ) {
                    printf( " Scegli una voce dal menu: " );
                    pp = 0;
                }
                else {
                    printf( " Scelta non valida, riprova: " );
                }

                fgets( buff, kDimBuff, stdin );

                // lunghezza della stringa
                for( l=0; buff[l]!='{parsed_message}'; ++l );

                if( l != 0 ) {
                    // elimina il new line a fine riga (se c'e')
                    if( buff[l-1] == '\n' ) buff[--l] = '{parsed_message}';
                    // rileva la scelta dell'utente
                    if( Numero(buff) ) scelta = atoi( buff );
                }
            }

            printf( "\n" );
        }
    }

    return scelta;
}

int main() {
    int sel_menu;

    do {
        sel_menu = Menu( kStrTitoloMenu, kStrVociMenu, kTotaleCmnd );

        switch( sel_menu ) {
            case kCmnd_Addizione:
                printf( " Addizione\n" );
                break;
            case kCmnd_Sottrazione:
                printf( " Sottrazione\n" );
                break;
            case kCmnd_Moltiplicazione:
                printf( " Moltiplicazione\n" );
                break;
            case kCmnd_Divisione:
                printf( " Divisione\n" );
                break;
            default: ;
        }
    } while( sel_menu != kCmnd_Uscita );

    return 0;
}';
                    // rileva la scelta dell'utente
                    if( Numero(buff) ) scelta = atoi( buff );
                }
            }

            printf( "\n" );
        }
    }

    return scelta;
}

int main() {
    int sel_menu;

    do {
        sel_menu = Menu( kStrTitoloMenu, kStrVociMenu, kTotaleCmnd );

        switch( sel_menu ) {
            case kCmnd_Addizione:
                printf( " Addizione\n" );
                break;
            case kCmnd_Sottrazione:
                printf( " Sottrazione\n" );
                break;
            case kCmnd_Moltiplicazione:
                printf( " Moltiplicazione\n" );
                break;
            case kCmnd_Divisione:
                printf( " Divisione\n" );
                break;
            default: ;
        }
    } while( sel_menu != kCmnd_Uscita );

    return 0;
}

Ultima modifica effettuata da AldoBaldo 02/05/16 22:57

ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.

03/05/16 5:46

Mattia99

È lo stesso anche se io continuo a vederla meno leggibile e un po più compicata..
Sarà un mio problema, bo :_doubt:

aaa

03/05/16 6:41

Postato originariamente da Mattia99:

Non mi sembra che ci siano dei file aperti in input,

Non c'entra nulla questa frase Mattia... È stdin il file in input ed è vero che il fflush funziona solo con Visual C (e non tutte le versioni) ... Non è il metodo corretto da suggerire ed imparare.

03/05/16 8:15

Mattia99

Non lo sapevo, io lo uso spesso e perciò ho suggerito cosi..
Credevo funzionasse sempre! Grazie, buono a sapersi

aaa

03/05/16 8:16

lumo

Postato originariamente da AldoBaldo:
// lunghezza della stringa
for( l=0; buff[l]!='

Postato originariamente da AldoBaldo:
// lunghezza della stringa
for( l=0; buff[l]!='{parsed_message}'; ++l );

if( l != 0 ) {
// elimina il new line a fine riga (se c'e')
if( buff[l-1] == '\n' ) buff[--l] = '{parsed_message}';
// rileva la scelta dell'utente
if( Numero(buff) ) scelta = atoi( buff );

Che io sappia atoi() scarta tutto quello che non c'entra dopo i caratteri numerici, quindi non serve nemmeno eliminare il newline
(A proposito, strlen è brutta? :rotfl:

)'; ++l );

if( l != 0 ) {
// elimina il new line a fine riga (se c'e')
if( buff[l-1] == '\n' ) buff[--l] = '

Che io sappia atoi() scarta tutto quello che non c'entra dopo i caratteri numerici, quindi non serve nemmeno eliminare il newline
(A proposito, strlen è brutta? :rotfl:

)';
// rileva la scelta dell'utente
if( Numero(buff) ) scelta = atoi( buff );

Che io sappia atoi() scarta tutto quello che non c'entra dopo i caratteri numerici, quindi non serve nemmeno eliminare il newline
(A proposito, strlen è brutta? :rotfl:

)

aaa

03/05/16 13:08

mariognai

Postato originariamente da Mattia99:

Ciao! Volevo darti una soluzione più semplice per il tuo problema che, come avrai capito, è legato all'input dell'utente.
Se non sbaglio la scanf restituisce 1 quando l'input è un intero.
In questo caso ti basterà un semplice ciclo di controllo:

while (scanf("%d", &sel_menu) != 1) {
      printf("Inserisci un'intero: \n");
      fflush(stdin);
      scanf("%d",&sel_menu);
   }

Non vorrei sbagliare, ma credo dovrebbe funzionare cosi.. :k:

Prova a seguire il consiglio che ti ha dato il mio amico, avevo pensato anche io alla stessa soluzione.

Ultima modifica effettuata da mariognai 03/05/16 15:14

aaa

03/05/16 13:58

A quanto ho capito, restituisce uno quando il valore in input è 1.

Ma di cosa parli?

1 2 3