1 / 40

Programmazione di Calcolatori

Programmazione di Calcolatori. Lezione XXIV: gli stack e le liste di variabili strutturate. Stack di interi e liste di record. Graficamente:. struct stoi_item { ……. struct stoi_item *successivo; };. …. …. …. …. …. stoi *stack. NULL. Stack di interi: definizione dei tipi.

mab
Télécharger la présentation

Programmazione di Calcolatori

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Programmazione di Calcolatori Lezione XXIV: gli stack e le liste di variabili strutturate Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  2. Stack di interi e liste di record • Graficamente: struct stoi_item { ……. struct stoi_item *successivo; }; … … … … … stoi *stack NULL Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  3. Stack di interi: definizione dei tipi // definizione del tipo strutturato elemento dello // stack di interi struct stoi_item { // valore dell'elemento int valore; // riferimento al prossimo elemento struct stoi_item *successivo; }; // definizione del tipo di una lista di interi typedef struct stoi_item * stoi; Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  4. InitStack() • La logica: stoi stack NULL • La funzione: // inizializza uno stack di interi a stack vuoto void stoiIni (stoi *stack) { // inizializza lo stack a stack vuoto *stack = NULL; }; Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  5. Generazione di un nuovo elemento • La logica: VALORE NULL • La funzione: // alloca memoria e inizializza un nuovo elemento dello stack structstoi_item*stoiItemIni(int valore) { // definisce un puntatore per il nuovo elemento dello stack structstoi_item *new_item; // alloca memoria per il nuovo elemento new_item = (structstoi_item *) malloc(sizeof(structstoi_item)); // se l’operazione ha esito positivo if (new_item != NULL) { // inizializza opportunamente i campi valore e successivo new_item -> valore = valore; new_item -> successivo = NULL; }; // restituisce il riferimento al nuovo elemento, se l’allocazione // di memoria ha avuto esito positivo; NULL altrimenti return(new_item); }; struct stoi_item *new_item Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  6. Push() • La logica: stoi stack X NULL (1) … … … … (2) NULL struct stoi_item *new_item Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  7. Push() • La funzione: // Costanti simboliche per gli esiti di una operazione #define NEG_RESULT 0 #define POS_RESULT 1 … // aggiunge un nuovo valore sullo stack int push(stoi *stack, int valore) { // definisce un puntatore al nuovo elemento struct stoi_item *new_item; // inizializza il nuovo elemento new_item = stoiItemIni(valore); // se la generazione del nuovo elemento fallisce termina con esito // negativo if (new_item == NULL) return(NEG_RESULT); // altrimenti inserisce il nuovo elemento sullo stack new_item -> successivo = *stack; *stack = new_item; // termina con esito positivo return(POS_RESULT); }; Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  8. Pop() • La logica: (2) X X stoi stack (3) NULL valore … … (1) struct stoi_item *temp int val valore Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  9. Pop() • La funzione: // restituisce ed elimina l’ultimo valore inserito sullo stack int pop(stoi *stack, int *val) { // definisce una variabile di appoggio per la testa dello stack struct stoi_item *temp; // se lo stack e' vuoto termina con esito negativo if (stoiEmpty(*stack)) return(NEG_RESULT); // altrimenti memorizza nella variabile riferita dal parametro val il valore // sulla testa dello stack *val = (*stack) -> valore; // estrae la testa dallo stack e recupera la memoria per questo allocata temp = *stack; *stack = (*stack) -> successivo; free(temp); // termina con esito positivo return(POS_RESULT); } Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  10. Top() • La logica: valore stoi *stack NULL • La funzione: valore … … // restituisce l’ultimo valore inserito sullo stack int top(stoi stack, int *val) { // se lo stack e' vuoto termina con esito negativo if (stoiEmpty(stack)) return(NEG_RESULT); // altrimenti memorizza nella variabile riferita dal parametro val il valore // sulla testa dello stack *val = stack -> valore; // termina con esito positivo return(POS_RESULT); }; int val Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  11. Gestione di uno Stack di interi • Specifiche: • implementare una soluzione per il tipo di dato astratto stack di interi che preveda le seguenti operazioni: • inizializzazione • Push() • Top() • Pop() • visualizzazione del contenuto • test di stack vuoto • reset Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  12. Organizzazione del codice: file e loro contenuto • Definizione dei tipi: • stoi_tipi.h: definizioni dei tipi, strutturati e non, utilizzati nella implementazione del tipo di dato astratto “stackofinteger” (stoi) • Codice sorgente: • stoi_main.c: codice per l’attivazione delle operazioni implementate per il tipo di dato astratto stoi • stoi_ges.c: definizione delle funzioni che implementano le operazioni definite sul tipo di dato astratto stoi • stoi_uti.c: definizione delle utilities di supporto alle funzioni che implementano le operazioni definite sul tipo di dato astratto stoi Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  13. Organizzazione del codice: file e loro contenuto • Dichiarazioni extern • stoi_ges.h: dichiarazioni extern delle funzioni che implementano le operazioni definite sul tipo di dato astratto stoi • stoi_uti.h: dichiarazioni extern delle utilities di supporto alle funzioni che implementano le operazioni definite sul tipo di dato astratto stoi • Pseudodichiarazioni: • stoi_const.h: pseudodichiarazioni per le costanti simboliche utilizzate nella implementazione del tipo di dato astratto stoi • stoi_msg.h: pseudodichiarazioni per i messaggi restituiti nella implementazione del tipo di dato astratto stoi Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  14. Gestione di uno Stack di interi: file stoi_tipi.h // Nome e posizione del file: // Lezione_XXIV/stoi_tipi.h // Descrizione del contenuto del file: // definizioni dei tipi, strutturati e non, utilizzati nella // implementazione del tipo di dato astratto “stack of integer” //tramite una lista di variabili strutturate // definizione del tipo strutturato elemento dello stack di interi struct stoi_item { // valore dell'elemento int valore; // riferimento al prossimo elemento struct stoi_item *successivo; }; // definizione del tipo stack di interi typedef struct stoi_item *stoi; Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  15. Gestione di uno Stack di interi: file stoi_ges.c // Nome e posizione del file: // Lezione_XXIV/stoi_ges.c // Descrizione del contenuto del file: // definizione delle funzioni che implementano le operazioni definite // sul tipo di dato astratto "stack of integer" // PSEUDODICHIARAZIONI // pseudodichiarazioni per i messaggi restituiti nella implementazione del // tipo di dato astratto "stack of integer" #include "./stoi_msg.h" // pseudodichiarazioni per le costanti simboliche utilizzate nella // implementazione del tipo di dato astratto "stack of integer" #include "./stoi_const.h" // DEFINIZIONI DI TIPO // definizioni dei tipi, strutturati e non, utilizzati nella implementazione del tipo // di dato astratto “stack of integer” tramite una lista di variabili strutturate #include "./stoi_tipi.h" Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  16. Gestione di uno Stack di interi: file stoi_ges.c // DICHIARAZIONI EXTERN // inclusione del file di intestazione della libreria standard // che contiene definizioni di macro, costanti e dichiarazioni di // funzioni e tipi funzionali alle varie operazioni di I/O #include <stdio.h> // inclusione del file di intestazione della libreria che contiene // definizioni di macro, costanti e dichiarazioni di funzioni e tipi di // interesse generale #include <stdlib.h> // dichiarazioni extern delle utilities di supporto alle funzioni che // implementano le operazioni definite sul tipo di dato astratto //“stack of integer” #include "./stoi_uti.h“ Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  17. Gestione di uno Stack di interi: file stoi_ges.c // Nome della funzione: // stoiEmpty() // Tipo, nome e significato dei parametri della funzione: // stoi stack: riferimento alla testa dello stack // Descrizione della funzionalita' implementata: // implementa il test di stack vuoto // Tipo e significato del valore restituito: // int: TRUE se la lista è vuota; // FALSE altrimenti int stoiEmpty(stoi stack) { // restituisce TRUE se lo stack è vuoto, FALSE altrimenti if (stack == NULL) return(TRUE); else return(FALSE); }; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  18. Gestione di uno Stack di interi: file stoi_ges.c // Nome della funzione: // push() // Tipo, nome e significato dei parametri della funzione: // stoi *stack: riferimento al puntatore di accesso allo stack di interi // int valore: valore da inserire sullo stack // Descrizione della funzionalita' implementata: // inserisce sullo stack un elemento per il valore // Tipo e significato del valore restituito: // int: POS_RESULT se l'operazione ha avuto esito positivo; // NEG_RESULT altrimenti int push(stoi *stack, int valore) { // definisce un puntatore al nuovo elemento struct stoi_item *new_item; // inizializza il nuovo elemento new_item = stoiItemIni(valore); // se la generazione del nuovo elemento fallisce termina con esito negativo if (new_item == NULL) return(NEG_RESULT); // altrimenti inserisce il nuovo elemento sullo stack new_item -> successivo = *stack; *stack = new_item; // termina con esito positivo return(POS_RESULT); }; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  19. Gestione di uno Stack di interi: file stoi_ges.c // Nome della funzione: // stoiVis() // Tipo, nome e significato dei parametri della funzione: // stoi stack: riferimento all'ultimo elemento inserito nello stack // Descrizione della funzionalita' implementata: // visualizza gli interi memorizzati nello stack, in ordine // inverso rispetto a quello di inserimento. // Tipo e significato del valore restituito: // alcuno void stoiVis (stoi stack) { // se la lista è vuota visualizza un opportuno messaggio if (stoiEmpty(stack)) printf(EMPTY_STOI); // altrimenti else // scandisce la lista while (stack != NULL) { // visualizza il contenuto dell'elemento corrente printf(" <- %d", stack -> valore); // considera l'elemento successivo a quello corrente stack = stack -> successivo; }; }; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  20. Gestione di uno Stack di interi: file stoi_ges.c // Nome della funzione: // top() // Tipo, nome e significato dei parametri della funzione: // stoi stack: riferimento alla testa dello stack // int *val: riferimento alla variabile nella quale memorizzare // il valore sulla testa dello stack // Descrizione della funzionalita' implementata: // se lo stack non e' vuoto, accede al valore memorizzato dalla testa, // lo memorizza nella variabile riferita dal parametro e termina con // successo. Altrimenti, termina con esito negativo. // Tipo e significato del valore restituito: // int: POS_RESULT se lo stack non e' vuoto; // NEG_RESULT altrimenti int top(stoi stack, int *val) { // se lo stack e' vuoto restituisce esito negativo if (stoiEmpty(stack)) return(NEG_RESULT); // altrimenti memorizza nella variabile riferita dal parametro val // il valore sulla testa dello stack *val = stack-> valore; // termina con esito positivo return(POS_RESULT); } Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  21. Gestione di uno Stack di interi: file stoi_ges.c // Nome della funzione: // pop() // Tipo, nome e significato dei parametri della funzione: // stoi *stack: riferimento alla testa dello stack // int *val: riferimento alla variabile nella quale memorizzare // il valore sulla testa dello stack // Descrizione della funzionalita' implementata: // se lo stack non e' vuoto, accede al valore memorizzato dalla testa // e lo memorizza nella variabile riferita dal parametro; estrae la // testa dallo stack recuperando la memoria per questo allocata, e // termina con successo. Termina con esito negativo, altrimenti. // Tipo e significato del valore restituito: // int: POS_RESULT se lo stack non e' vuoto. // NEG_RESULT altrimenti int pop(stoi *stack, int *val) { // definisce una variabile di appoggio per la testa dello stack struct stoi_item *temp; // se lo stack e' vuoto termina con esito negativo if (stoiEmpty(*stack)) return(NEG_RESULT); // altrimenti memorizza nella variabile riferita dal parametro val // il valore sulla testa dello stack *val = (*stack) -> valore; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  22. Gestione di uno Stack di interi: file stoi_ges.c // estrae la testa dallo stack e recupera la memoria per questo allocata temp = *stack; *stack = (*stack) -> successivo; free(temp); // termina con esito positivo return(POS_RESULT); } Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  23. Gestione di uno Stack di interi: file stoi_ges.c // Nome della funzione: // stoiReset() // Tipo, nome e significato dei parametri della funzione: // stoi *stack: riferimento al puntatore alla testa dello stack // Descrizione della funzionalita' implementata: // azzera lo stack recuperando tutta la memoria allocata per i // suoi elementi // Tipo e significato del valore restituito: // alcuno void stoiReset (stoi *stack) { // definizione di una variabile intera da utilizzarsi nella // chiamata della pop() int valore; // esegue ripetutamente operazioni di pop() fino ad ottenere // uno stack vuoto while (pop(stack, &valore) != NEG_RESULT); }; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  24. Gestione di uno Stack di interi: file stoi_ges.c // Nome della funzione: // stoiInit() // Tipo, nome e significato dei parametri della funzione: // stoi *stack: riferimento al puntatore alla testa dello stack // Descrizione della funzionalita' implementata: // inizializza uno stack di interi a stack vuoto // Tipo e significato del valore restituito: // alcuno void stoiInit (stoi *stack) { // inizializza lo stack a stack vuoto *stack = NULL; }; Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  25. Gestione di un Stack di interi: file stoi_ges.h // Nome e posizione del file: // Lezione_XXIV/stoi_ges.h // Descrizione del contenuto del file: // contiene le dichiarazioni extern delle funzioni che implementano le // operazioni definite sul tipo di dato astratto “stack of integer” extern int stoiEmpty(stoi); extern int push(stoi *, int); extern void stoiVis(stoi); extern int top(stoi, int *); extern int pop(stoi *, int *); extern void stoiReset (stoi *); extern void stoiInit(stoi *); Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  26. Gestione di uno Stack di interi: file stoi_uti.c // Nome e posizione del file: // Lezione_XXIV/stoi_uti.c // Descrizione del contenuto del file: // definizione delle utilities di supporto alle funzioni che implementano le // operazioni definite sul tipo di dato astratto “stack of integer” // DEFINIZIONI DI TIPO // definizioni dei tipi, strutturati e non, utilizzati nella implementazione del tipo // di dato astratto “stack of integer” tramite una lista di variabili strutturate #include "./stoi_tipi.h" // DICHIARAZIONI EXTERN // inclusione del file di intestazione della libreria // standard che contiene definizioni di macro, // costanti e dichiarazioni di funzioni e tipi funzionali // alle varie operazioni di I/O #include <stdio.h> // inclusione del file di intestazione della libreria che contiene // definizioni di macro, costanti e dichiarazioni di funzioni e tipi // di interesse generale #include <stdlib.h> Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  27. Gestione di uno Stack di interi: file stoi_uti.c // Nome della funzione: // stoiItemIni() // Tipo, nome e significato dei parametri della funzione: // int valore: intero memorizzato dal nuovo elemento dello stack // Descrizione della funzionalita' implementata: // alloca memoria per un nuovo elemento di uno stack di interi e lo // inizializza con il valore del parametro // Tipo e significato del valore restituito: // struct stoi_item *: riferimento ad un nuovo elemento di uno stack di // interi, se la sua allocazione ha esito positivo; // NULL altrimenti struct stoi_item *stoiItemIni(int valore) { // definisce un puntatore per il nuovo elemento dello stack struct stoi_item *new_item; // alloca memoria per il nuovo elemento new_item = (struct stoi_item *) malloc(sizeof(struct stoi_item)); // se l’operazione ha esito positivo if (new_item != NULL) { // inizializza opportunamente i campi valore e successivo new_item -> valore = valore; new_item -> successivo = NULL; }; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  28. Gestione di uno Stack di interi: file stoi_uti.c // restituisce il riferimento al nuovo elemento, se la sua allocazione // di memoria ha avuto esito positivo, NULL altrimenti return(new_item); }; Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  29. Gestione di uno Stack di interi: file stoi_uti.h // Nome e posizione del file: //Lezione_XXIV/stoi_uti.h // Descrizione del contenuto del file: // contiene le dichiarazioni extern delle utilities di supporto alle // funzioni che implementano le operazioni definite sul tipo di // dato astratto “stack of integer” extern struct stoi_item *stoiItemIni(int); Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  30. Gestione di uno Stack di interi: file stoi_main.c // Nome e posizione del file: // Lezione_XXIV/stoi_main.c // Descrizione del contenuto del file: // codice per l’attivazione delle funzionalità di gestione dello stack // di interi // PSEUDODICHIARAZIONI // pseudodichiarazioni per i messaggi restituiti nella implementazione del // tipo di dato astratto "stack of integer" #include "./stoi_msg.h" // pseudodichiarazioni per le costanti simboliche utilizzate nella // implementazione del tipo di dato astratto "stack of integer" #include "./stoi_const.h" // DEFINIZIONI DI TIPO // definizioni dei tipi, strutturati e non, utilizzati nella implementazione del tipo // di dato astratto “stack of integer” tramite una lista di variabili strutturate #include "./stoi_tipi.h" // DICHIARAZIONE EXTERN // inclusione del file di intestazione della libreria // standard che contiene definizioni di macro, // costanti e dichiarazioni di funzioni e tipi funzionali // alle varie operazioni di I/O #include <stdio.h> Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  31. Gestione di uno Stack di interi: file stoi_main.c // dichiarazioni extern delle utilities di supporto alle funzioni che implementano // le operazioni definite sul tipo di dato astratto //“stack of integer” #include "./stoi_uti.h“ // dichiarazioni extern delle funzioni che implementano le operazioni // definite sul tipo di dato astratto stoi #include "./stoi_ges.h" Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  32. Gestione di uno Stack di interi: file stoi_main.c // Nome della funzione: // StoiMenu() // Tipo, nome e significato dei parametri della funzione: // stck *stack: riferimento al puntatore alla testa dello stack di interi // Descrizione della funzionalita' implementata: // implementa il menu di scelta per le operazioni definite sul tipo di // dato astratto “stack of integer” // Tipo e significato del valore restituito: // alcuno void stoiMenu(stoi *stack) { // definisce e inizializza la variabile che permette l'uscita dal programma int quit = 0; // definisce una variabile per i valori oggetto della push() // e per il risultato della top() e della pop() int valore; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  33. Gestione di uno Stack di interi: file stoi_main.c • // visualizza le possibili scelte • printf(SELECT_FUN_STOI); • printf(PUSH); printf(TOP); printf(POP); • printf(RESET_LOI); printf(DISPLAY_STOI); • printf(EMPTY_STOI_TEST); • printf(LEAVE_MAN_STOI); • printf(SELECT_OP_STOI); • // acquisisce la scelta • scanf("%d", &selezione); • // discrimina tra le diverse scelte • switch (selezione) • { • case 1: // Push() • // acquisisce il valore oggetto della Push() • printf(ITEM_VALUE_REQ); • scanf("%d", &valore); • // chiama la funzione che implementa l’operazione Push(), • // testa l'esito dell'operazione e lo visualizza • if (push(stack, valore) == POS_RESULT) • printf(POS_RES_MSG); • else • { • printf(NEG_RES_MSG); • printf(ITEM_GEN_FAILED); • }; • break; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  34. Gestione di uno Stack di interi: file stoi_main.c • case 2: // Top() • // chiama la funzione che implementa l'operazione Top() • // valuta l'esito dell'operazione e lo visualizza. Se l'esito e‘ • // positivo visualizza il valore sulla testa dello stack • if (top(*stack, &valore) == POS_RESULT) • printf("\nTop(): %d\n", valore); • else • printf(POP_FAILED); • break; • case 3: // Pop() • // chiama la funzione che implementa l'operazione Pop() • // valuta l'esito dell'operazione e lo visualizza. Se l'esito e' • // positivo visualizza il valore sulla testa dello stack • if (pop(stack, &valore) == POS_RESULT) • printf("\nPop(): %d\n", valore); • else • printf(TOP_FAILED); • break; • case 4: // reset dello stack • // chiama la funziona che azzera lo stack • stoiReset(stack); • break; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  35. Gestione di uno Stack di interi: file stoi_main.c case 5: // visualizzazione del contenuto dello stack // chiama la funzione che visualizza il contenuto dello stack stoiVis(*stack); break; case 6: // test di stack vuoto // chiama la funzione che testa se lo stack e’ vuoto e visualizza // il risultato del test if (stoiEmpty(*stack)) printf(EMPTY_STOI); else printf(NOT_EMPTY_STOI); break; case 7: // uscita quit = 1; break; default: // selezione errata printf(WRONG_SELECTION); }; }; }; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  36. Gestione di uno Stack di interi: file stoi_main.c // Nome della funzione: // main() // Tipo, nome e significato dei parametri della funzione: // alcuno // Descrizione della funzionalita' implementata: // chiamante // Tipo e significato del valore restituito: // alcuno int main() { // definisce il puntatore di accesso allo stack di interi; stoi stack; // inizializza lo stack stoiInit(&stack); // chiama la funzione che implementa il menu di scelta // delle funzionalita' di gestione dello stack di interi stoiMenu(&stack); // recupera la memoria allocata per lo stack stoiReset(&stack); return(0); }; Continua … Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  37. Gestione di uno Stack di interi: file stoi_const.h // Nome e posizione del file: // Lezione_XXIV/stoi_const.h //Descrizione del contenuto del file: // pseudodichiarazioni per le costanti simboliche utilizzate nella // implementazione del tipo di dato astratto "stack of integer“ // definizione delle costanti simboliche per gli esiti di una operazione #define NEG_RESULT 0 #define POS_RESULT 1 // definizione delle costanti mnemoniche per gli esiti di un test #define TRUE 1 #define FALSE 0 Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  38. Gestione di uno Stack di interi: file stoi_msg.h // Nome e posizione del file: // Lezione_XXIV/stoi_msg.h // Descrizione del contenuto del file: //pseudodichiarazioni per i messaggi restituiti nella implementazione del //tipo di dato astratto "stack of integer" // definizione delle costanti simboliche per i messaggi utilizzati per il menu #define SELECT_FUN_STOI "\nSelezionare Funzionalita'\n" #define PUSH "\n1: Push()" #define TOP "\n2: Top()" #define POP "\n3: Pop()" #define RESET_LOI "\n4: Azzera lo stack" #define DISPLAY_STOI "\n5: Visualizza lo stack" #define EMPTY_STOI_TEST "\n6: Test di stack vuoto" #define LEAVE_MAN_STOI "\n7: Interrompi" #define SELECT_OP_STOI "\n\nSelezione: " #define WRONG_SELECTION "\nSelezionare 1, 2, 3, 4, 5, 6 o 7" // definizione delle costanti simboliche per i messaggi di descrizione // per l'esito delle operazioni #define ITEM_GEN_FAILED "\nGenerazione del nuovo elemento fallita" #define POP_FAILED "\nPop()fallita: stack vuoto\n" #define TOP_FAILED "\nTop()fallita: stack vuoto\n" // definizione delle costanti simboliche per i messaggi descrittivi dello stack #define EMPTY_STOI "\nStack vuoto\n" #define NOT_EMPTY_STOI "\nStack non vuoto\n" #define STOI "\nStack: Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  39. Gestione di uno Stack di interi: file stoi_msg.h // definizione delle costanti simboliche per i messaggi per l'esito delle // operazioni #define NEG_RES_MSG "\nOperazione fallita\n" #define POS_RES_MSG "\nOperazione terminata con successo\n" // definizione delle costanti simboliche per i messaggi per l'acquisizione di // dati #define ITEM_VALUE_REQ "\nPush(?): " Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

  40. Grafo delle chiamate stoiInit() ./stoi_ges.c main() ./stoi_main.c stoiReset() ./stoi_ges.c stoiMenu() ./stoi_main.c stoiVis() ./stoi_ges.c push() ./stoi_ges.c stoiEmpty() ./stoi_ges.c top() ./stoi_ges.c pop() ./stoi_ges.c stoiItemIni() ./stoi_uti.c Programmazione di Calcolatori: gli stack e le liste di variabili strutturate

More Related