FONDAMENTI DI INFORMATICA II Ingegneria Gestionale a a

FONDAMENTI DI INFORMATICA II Ingegneria Gestionale a. a. 2001 -2002 - 4° Ciclo Pile e Code 1

Pile e Code Le Pile (o Stack) sono liste concatenate sulle quali i nuovi nodi possono essere aggiunti o rimossi soltanto dalla sua testa. Una struttura di questo tipo viene detta Last In First Out (LIFO), poiché l’ultimo nodo aggiunto è anche il primo ad essere rimosso. Operazioni per le pile Push: crea un nodo in cui memorizza i dati passati dalla funzione chiamante e lo posiziona alla testa della pila. Pop: rimuove un nodo dalla testa della pila, acquisisce i dati in esso contenuti, rilascia la memoria allocata dal nodo estratto e restituisce il valore booleano true se l’operazione è andata a buon fine, altrimenti false. 2

Pile e Code Utilizzo delle pile Sono fondamentali, sotto il controllo del sistema operativo, per l’esecuzione della corretta sequenza delle operazioni nel corso di un programma. Un esempio è l’utilizzo per tenere traccia delle chiamate di funzione memorizzando l’indirizzo di ritorno della funzione chiamante. Programma __________ Funzione. A() Addr 1 __________ _____ Funzione. B push(Addr 2) _____ push(Addr 1) Funzione. A __________ Return Funzione. B() Addr 2 _____ pop(Addr 2) _____ pop(Addr 1) Return 3

Pile e Code Esempio per le pile // Stack class template definition // Derived from class List #ifndef STACK_H #define STACK_H #include "list. h" template< class STACKTYPE > class Stack : private List< STACKTYPE > { public: void push( const STACKTYPE &d ) { insert. At. Front( d ); } bool pop( STACKTYPE &d ) { return remove. From. Front( d ); } bool is. Stack. Empty() const { return is. Empty(); } void print. Stack() const { print(); }}; #endif 4

Pile e Code // Driver to test the template Stack class #include <iostream> #include "stack. h" using std: : endl; int main() { Stack< int > int. Stack; int pop. Integer, i; cout << "processing an integer Stack" << endl; for ( i = 0; i < 4; i++ ) { int. Stack. push( i ); int. Stack. print. Stack(); } while ( !int. Stack. is. Stack. Empty() ) { int. Stack. pop( pop. Integer ); cout << pop. Integer << " popped from stack" << endl; int. Stack. print. Stack(); } 5

Pile e Code Stack< double > double. Stack; double val = 1. 1, popdouble; cout << "processing a double Stack" << endl; for ( i = 0; i < 4; i++ ) { double. Stack. push( val ); double. Stack. print. Stack(); val += 1. 1; } while ( !double. Stack. is. Stack. Empty() ) { double. Stack. pop( popdouble ); cout << popdouble << " popped from stack" << endl; double. Stack. print. Stack(); } return 0; } 6

Pile e Code processing an integer Stack The list is: 0 The list is: 1 0 The list is: 2 1 0 The list is: 3 2 1 0 3 popped from stack The list is: 2 1 0 2 popped from stack The list is: 1 0 1 popped from stack The list is: 0 0 popped from stack The list is empty 7

Pile e Code processing a double Stack The list is: 1. 1 The list is: 2. 2 1. 1 The list is: 3. 3 2. 2 1. 1 The list is: 4. 4 3. 3 2. 2 1. 1 4. 4 popped from stack The list is: 3. 3 2. 2 1. 1 3. 3 popped from stack The list is: 2. 2 1. 1 2. 2 popped from stack The list is: 1. 1 popped from stack The list is empty All nodes destroyed 8

Pile e Code Le code sono liste concatenate nelle quali i nodi sono inseriti soltanto in coda e rimossi soltanto dalla testa. Una struttura di questo tipo viene detta First In First Out (FIFO), poiché il primo nodo aggiunto è anche il primo ad essere rimosso. Operazioni per le pile Enqueue: crea un nodo in cui memorizza i dati passati dalla funzione chiamante e lo posiziona alla fine della coda. Dequeue: rimuove un nodo dalla testa della coda, acquisisce i dati in esso contenuti, rilascia la memoria allocata dal nodo estratto e restituisce il valore booleano true se l’operazione è andata a buon fine, altrimenti false. 9

Pile e Code Utilizzo delle code Le code, che hanno la proprietà di portare all’elaborazione i nodi che da più tempo sono stati inseriti (ossia i nodi più “vecchi”), hanno numerose applicazioni nell’ambito delle gestioni di un sistema operativo. Tra queste ricordiamo: - Le code di elaborazione dei processi nei sistemi Time Sharing - Le code di stampa. - Le code di instradamento dei messaggi gestiti da un router …ecc. 10

Pile e Code Esempio per le code // Queue class template definition // Derived from class List #ifndef QUEUE_H #define QUEUE_H #include "list. h" template< class QUEUETYPE > class Queue: private List< QUEUETYPE > { public: void enqueue( const QUEUETYPE &d ) { insert. At. Back( d ); } bool dequeue( QUEUETYPE &d ) { return remove. From. Front( d ); } bool is. Queue. Empty() const { return is. Empty(); } void print. Queue() const { print(); } }; #endif 11

Pile e Code // Driver to test the template Queue class #include <iostream> #include "queue. h" using std: : endl; int main() { Queue< int > int. Queue; int dequeue. Integer, i; cout << "processing an integer Queue" << endl; for ( i = 0; i < 4; i++ ) { int. Queue. enqueue( i ); int. Queue. print. Queue(); } while ( !int. Queue. is. Queue. Empty() ) { int. Queue. dequeue( dequeue. Integer ); cout << dequeue. Integer << " dequeued" << endl; int. Queue. print. Queue(); } 12

Pile e Code Queue< double > double. Queue; double val = 1. 1, dequeuedouble; cout << "processing a double Queue" << endl; } for ( i = 0; i < 4; i++ ) { double. Queue. enqueue( val ); double. Queue. print. Queue(); val += 1. 1; } while ( !double. Queue. is. Queue. Empty() ) { double. Queue. dequeue( dequeuedouble ); cout << dequeuedouble << " dequeued" << endl; double. Queue. print. Queue(); } return 0; 13

Pile e Code processing an integer Queue The list is: 0 1 2 3 0 dequeued The list is: 1 2 3 1 dequeued The list is: 2 3 2 dequeued The list is: 3 3 dequeued The list is empty 14

Pile e Code processing a float Queue The list is: 1. 1 2. 2 3. 3 4. 4 1. 1 dequeued The list is: 2. 2 3. 3 4. 4 2. 2 dequeued The list is: 3. 3 4. 4 3. 3 dequeued The list is: 4. 4 dequeued The list is empty All nodes destroyed 15