Corso di Fondamenti di Programmazione, edizione dell'a.a. 2009/2010
Canale A-D
Docente: Prof.ssa C. Petrioli
Responsabile esercitazioni: Prof. T. Mancini
31 Gennaio 2010 @ 12:10: corretti alcuni errori nelle specifiche dei comandi elimina da <coll> il primo elemento, elimina da <coll> l'ultimo elemento: il primo era erroneamente disabilitato per le code (dove l'eliminazione ovviamente avviene sempre e solo in testa), il secondo era erroneamente abilitato per le code.
24 Gennaio 2010 @ 16:10: corretto errore nella specifica del comando trova in <coll> la posizione dell'occorrenza numero <num_occ> del valore <valore>
Scrivere un programma che legga da tastiera ed esegua, uno alla volta, una sequenza di comandi per creare e gestire collezioni di vario tipo (liste, pile e code) e con elementi di vario tipo (interi, caratteri, stringhe).
Il programma mantiene in memoria lo stato della computazione (ovvero la composizione delle collezioni create e modificate tramite i comandi fino ad ora eseguiti) fino alla terminazione del programma, che avviene quando si riceve il comando esci oppure il carattere EOF.
>>".
crea MiaColl come lista di int stampa MiaColl >>MiaColl (lista di int): NULL aggiungi a MiaColl il valore 5 in testa aggiungi a MiaColl il valore 3 in coda stampa MiaColl >>MiaColl (lista di int): 5 -> 3 -> NULL aggiungi a MiaColl il valore 2 in posizione 1 stampa MiaColl >>MiaColl (lista di int): 5 -> 2 -> 3 -> NULL crea MiaColl come pila di char >>Errore: impossibile creare MiaColl crea MiaColl2 come pila di char aggiungi a MiaColl2 il valore a aggiungi a MiaColl2 il valore b aggiungi a MiaColl2 il valore c stampa MiaColl2 >>MiaColl2 (pila di char): c -> b -> a -> NULL crea MiaColl3 come coda di char* aggiungi a MiaColl3 il valore "Una stringa" aggiungi a MiaColl3 il valore "Seconda stringa" aggiungi a MiaColl3 il valore "Terza stringa" stampa MiaColl3 >>MiaColl3 (coda di char*): "Una stringa" -> "Seconda stringa" -> "Terza stringa" -> NULL aggiungi a MiaColl3 il valore "Quarta stringa" in posizione 2 >>Errore: operazione non permessa su MiaColl3 stampa MiaColl3 >>MiaColl3 (coda di char*): "Una stringa" -> "Seconda stringa" -> "Terza stringa" -> NULL distruggi MiaColl3 stampa MiaColl3 >>Errore: MiaColl3 non esiste lunghezza di MiaColl >>3 aggiungi a MiaColl il valore 3 in coda aggiungi a MiaColl il valore 2 in posizione 3 stampa MiaColl >>MiaColl (lista di int): 5 -> 2 -> 3 -> 2 -> 3 -> NULL elimina da MiaColl il primo elemento stampa MiaColl >>MiaColl (lista di int): 2 -> 3 -> 2 -> 3 -> NULL elimina da MiaColl l'occorrenza numero 2 del valore 3 stampa MiaColl >>MiaColl (lista di int): 2 -> 3 -> 2 -> NULL elimina da MiaColl tutte le occorrenze del valore 2 stampa MiaColl >>MiaColl (lista di int): 3 -> NULL crea MiaColl4 come pila di int aggiungi a MiaColl4 il valore 1 aggiungi a MiaColl4 il valore 3 aggiungi a MiaColl4 il valore 2 stampa MiaColl4 >>MiaColl4 (pila di int): 2 -> 3 -> 1 -> NULL elimina da MiaColl tutti gli elementi di MiaColl4 >>Errore: operazione non permessa su MiaColl4 trasforma MiaColl4 in lista stampa MiaColl4 >>MiaColl4 (lista di int): 2 -> 3 -> 1 -> NULL elimina da MiaColl tutti gli elementi di MiaColl4 stampa MiaColl >>MiaColl (lista di int): NULL trasforma MiaColl4 in pila stampa MiaColl4 >>MiaColl4 (pila di int): 2 -> 3 -> 1 -> NULL aggiungi a MiaColl il valore 2 aggiungi a MiaColl il valore 7 stampa MiaColl >>MiaColl (lista di int): 2 -> 7 -> NULL aggiungi a MiaColl tutti gli elementi di MiaColl4 stampa MiaColl >>MiaColl (lista di int): 2 -> 7 -> 2 -> 3 -> 1 -> NULL stampa MiaColl4 >>MiaColl4 (pila di int): 2 -> 3 -> 1 -> NULL elimina da MiaColl tutti gli elementi tranne quelli di MiaColl4 >>Errore: operazione non permessa su MiaColl4 trasforma MiaColl4 in lista stampa MiaColl4 >>MiaColl4 (lista di int): 2 -> 3 -> 1 -> NULL elimina da MiaColl tutti gli elementi tranne quelli di MiaColl4 stampa MiaColl >>MiaColl (lista di int): 2 -> 2 -> 3 -> 1 -> NULL aggiungi a MiaColl4 il valore 4 in testa stampa MiaColl4 >>MiaColl4 (lista di int): 4 -> 2 -> 3 -> 1 -> NULL aggiungi a MiaColl4 il valore 4 in coda stampa MiaColl4 >>MiaColl4 (lista di int): 4 -> 2 -> 3 -> 1 -> 4 -> NULL trova in MiaColl4 la posizione dell'occorrenza numero 2 del valore 4 >>4 trasforma MiaColl4 in coda stampa MiaColl4 >>MiaColl4 (coda di int): 4 -> 2 -> 3 -> 1 -> 4 -> NULL trova in MiaColl4 la posizione dell'occorrenza numero 2 del valore 4 >>Errore: operazione non permessa su MiaColl4 esci >>Arrivederci!
Come si vede il programma deve permettere all'utente di creare e distruggere liste, pile e code i cui elementi possono essere interi, caratteri o stringhe. Inoltre, le collezioni create possono essere modificate aggiungendo o eliminandone elementi, possono essere combinate tra loro, stampate su schermo, etc.
I comandi da interpretare ed eseguire vengono dati tutti su un'unica riga, e terminano con il carattere '\n'.
A valle dell'esecuzione di un comando, il programma stampa l'eventuale output su una sola riga, che inizia per ">>".
I comandi da implementare sono descritti in dettaglio nelle tabelle seguenti, dove viene indicato: la sintassi esatta (il linguaggio è case sensitive), le pre-condizioni (ovvero le condizioni sullo stato della computazione che devono essere soddisfatte affinché il comando possa essere eseguito, le post-condizioni (ovvero l'effetto dell'esecuzione del comando sullo stato della computazione), l'eventuale messaggio di output a valle dell'esecuzione del comando, ed alcuni esempi di utilizzo.
<coll>, <altra_coll>, etc. per indicare il nome di una collezione. Questo è una stringa di caratteri composta da lettere (minuscole e/o maiuscole), cifre ed il simbolo '_', che non inizia per cifra (le stesse regole che devono rispettare gli identificatori in C).
Ad esempio, _Mia_Collezione2 è un nome legale per una collezione, mentre 6coll non lo è.
<tipo_elem> che indica il tipo degli elementi di una collezione. Può assumere i seguenti valori: int, char, char*.
<tipo_coll> che indica il tipo di una collezione. Può assumere i seguenti valori: lista, pila, coda.
<coll>.
<coll> e tipo <tipo_coll>, in grado di contenere elementi di tipo <tipo_elem>.
Errore: impossibile creare <coll>".
crea Coll1 come lista di int crea Coll2 come pila di char* crea Coll3 come coda di char crea Coll2 come coda di char* >>Errore: impossibile creare Coll2 crea Coll4 come pila di char
<coll>.
<coll> viene distrutta, e la sua memoria liberata.
Errore: <coll> non esiste".
distruggi Coll4 distruggi Coll23 >>Errore: Coll23 non esiste
<coll>.
<coll>, un nuovo elemento, con il valore <valore>.
Il valore <valore>viene interpretato essere del tipo degli elementi di <coll>.
Il nuovo elemento viene inserito in posizione predefinita, che dipende dal tipo della collezione: in coda per le liste e le code, in testa per le pile.
Errore: <coll> non esiste".
aggiungi a Coll2 il valore "Una stringa" aggiungi a Coll1 il valore 2 aggiungi a Coll2 il valore "Seconda stringa"
<coll> esiste in memoria.
<coll>.
La collezione non viene modificata.
<coll> (<tipo_coll> di <tipo_elem>): <valore1> -> <valore2> -> ... -> <valoreN> -> NULL".
Errore: <coll> non esiste".
stampa Coll2 >>Coll2 (pila di char*): "Seconda stringa" -> "Una stringa" -> NULL stampa Coll1 >>Coll1 (lista di int): 2 -> NULL stampa Coll3 >>Coll3 (coda di char): NULL stampa Coll23 >>Errore: Coll23 non esiste
<coll>.
<coll>, un nuovo elemento, con il valore <valore>.
Il valore <valore> viene interpretato essere del tipo degli elementi di <coll>.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è una lista né una pila: "Errore: operazione non permessa su <coll>".
stampa Coll1 >>Coll1 (lista di int): 2 -> NULL aggiungi a Coll1 il valore 5 in testa stampa Coll1 >>Coll1 (lista di int): 5 -> 2 -> NULL stampa Coll3 >>Coll3 (coda di char): NULL aggiungi a Coll3 il valore c in testa >>Errore: operazione non permessa su Coll3
<coll>.
<coll>, un nuovo elemento, con il valore <valore>.
Il valore <valore> viene interpretato essere del tipo degli elementi di <coll>.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è una lista né una coda: "Errore: operazione non permessa su <coll>".
stampa Coll1 >>Coll1 (lista di int): 5 -> 2 -> NULL aggiungi a Coll1 il valore 3 in coda stampa Coll1 >>Coll1 (lista di int): 5 -> 2 -> 3 -> NULL stampa Coll3 >>Coll3 (coda di char): NULL aggiungi a Coll3 il valore c in coda stampa Coll3 >>Coll3 (coda di char): c -> NULL stampa Coll2 >>Coll2 (pila di char*): "Seconda stringa" -> "Una stringa" -> NULL aggiungi a Coll2 il valore "Hello" in coda >>Errore: operazione non permessa su Coll2 aggiungi a Coll233 il valore "Hello" in coda >>Errore: Coll233 non esiste
<coll>. <pos> è un intero.
<coll>, un nuovo elemento, con il valore <valore>. Il valore <valore> viene interpretato essere del tipo degli elementi di <coll>.
Dopo l'inserimento, il nuovo elemento avrà la posizione <pos> (0=primo, 1=secondo, etc.). In caso <pos> < 0, l'inserimento avviene in testa (come se <pos> fosse uguale a 0); in caso <pos> è maggiore della lunghezza della collezione, l'inserimento avviene in coda.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è una lista: "Errore: operazione non permessa su <coll>".
stampa Coll1 >>Coll1 (lista di int): 5 -> 2 -> 3 -> NULL aggiungi a Coll1 il valore 7 in posizione 2 stampa Coll1 >>Coll1 (lista di int): 5 -> 2 -> 7 -> 3 -> NULL aggiungi a Coll1 il valore 8 in posizione -28 stampa Coll1 >>Coll1 (lista di int): 8 -> 5 -> 2 -> 7 -> 3 -> NULL aggiungi a Coll1 il valore 9 in posizione 5 stampa Coll1 >>Coll1 (lista di int): 8 -> 5 -> 2 -> 7 -> 3 -> 9 -> NULL stampa Coll2 >>Coll2 (pila di char*): "Seconda stringa" -> "Una stringa" -> NULL aggiungi a Coll2 il valore "Hello" in posizione 1 >>Errore: operazione non permessa su Coll2
<coll>.
<coll>, un nuovo elemento, con il valore <valore>.
Il nuovo elemento viene inserito immediatamente prima della prima occorrenza di <altro_valore> nella collezione.
Se <altro_valore> non occorre mai, l'inserimento avviene in coda.
I valori <valore> e <altro_valore>vengono interpretati essere del tipo degli elementi di <coll>.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è una lista: "Errore: operazione non permessa su <coll>".
stampa Coll1 >>Coll1 (lista di int): 8 -> 5 -> 2 -> 7 -> 3 -> 9 -> NULL aggiungi a Coll1 il valore 6 prima di 7 stampa Coll1 >>Coll1 (lista di int): 8 -> 5 -> 2 -> 6 -> 7 -> 3 -> 9 -> NULL
<coll>.
<coll>, un nuovo elemento, con il valore <valore>. Il nuovo elemento viene inserito immediatamente dopo la prima occorrenza di <altro_valore> nella collezione.
Se <altro_valore> non occorre mai, l'inserimento avviene in coda.
I valori <valore> e <altro_valore>vengono interpretati essere del tipo degli elementi di <coll>.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è una lista: "Errore: operazione non permessa su <coll>".
stampa Coll1 >>Coll1 (lista di int): 8 -> 5 -> 2 -> 6 -> 7 -> 3 -> 9 -> NULL aggiungi a Coll1 il valore 8 dopo 7 stampa Coll1 >>Coll1 (lista di int): 8 -> 5 -> 2 -> 6 -> 7 -> 8 -> 3 -> 9 -> NULL aggiungi a Coll1 il valore 9 dopo 8 stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 5 -> 2 -> 6 -> 7 -> 8 -> 3 -> 9 -> NULL
<coll> e <altra_coll> esistono in memoria ed hanno gli elementi dello stesso tipo.
<altra_coll> viene aggiunto a <coll>.
Gli elementi di <altra_coll> vengono visitati da sinistra a destra, e vengono aggiunti a <coll> nell'ordine predefinito, che dipende dal tipo di <coll> (come se, per ognuno di essi venisse invocato il comando aggiungi a <coll> il valore <valore>).
La collezione <altra_coll> non viene modificata.
<coll> non esiste: "Errore: <coll> non esiste".
<altra_coll> non esiste: "Errore: <altra_coll> non esiste".
<coll> e <altra_coll> hanno elementi di tipo diverso: "Errore: operazione non permessa su <coll>".
stampa Coll2 >>Coll2 (pila di char*): "Seconda stringa" -> "Una stringa" -> NULL stampa Coll4 >>Errore: Coll4 non esiste crea Coll4 come pila di char* stampa Coll4 >>Coll4 (pila di char*): NULL aggiungi a Coll4 il valore "Hello" aggiungi a Coll4 il valore "Bye" stampa Coll4 >>Coll4 (pila di char*): "Bye" -> "Hello" -> NULL aggiungi a Coll4 tutti gli elementi di Coll2 stampa Coll4 >>Coll4 (pila di char*): "Una stringa" -> "Seconda stringa" -> "Bye" -> "Hello" -> NULL aggiungi a Coll4 tutti gli elementi di Coll1 >>Errore: operazione non permessa su Coll4
<coll> esiste in memoria.
<coll>, se esiste, viene eliminato dalla collezione, e la sua memoria liberata. Se tale elemento non esiste, la funzione non fa nulla.
<coll> non esiste: "Errore: <coll> non esiste".
stampa Coll4 >>Coll4 (pila di char*): "Una stringa" -> "Seconda stringa" -> "Bye" -> "Hello" -> NULL elimina da Coll4 il primo elemento stampa Coll4 >>Coll4 (pila di char*): "Seconda stringa" -> "Bye" -> "Hello" -> NULL crea Coll5 come lista di int stampa Coll5 >>Coll5 (lista di int): NULL elimina da Coll5 il primo elemento stampa Coll5 >>Coll5 (lista di int): NULL
<coll> esiste in memoria e non è di tipo pila né coda.
<coll>, se esiste, viene eliminato dalla collezione, e la sua memoria liberata. Se tale elemento non esiste, la funzione non fa nulla.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> è di tipo pila o coda: "Errore: operazione non permessa su <coll>".
stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 5 -> 2 -> 6 -> 7 -> 8 -> 3 -> 9 -> NULL elimina da Coll1 l'ultimo elemento stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 5 -> 2 -> 6 -> 7 -> 8 -> 3 -> NULL stampa Coll4 >>Coll4 (pila di char*): "Seconda stringa" -> "Bye" -> "Hello" -> NULL elimina da Coll4 l'ultimo elemento >>Errore: operazione non permessa su Coll4
<coll> esiste in memoria ed è di tipo lista, oppure è di tipo pila o coda e <pos> = 0.
<coll> in posizione <pos> (il primo, se <pos> = 0, il secondo se <pos> = 1, etc.), se esiste, viene eliminato dalla collezione, e la sua memoria liberata.
Se tale elemento non esiste, la funzione non fa nulla.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è di tipo lista e <pos> > 0: "Errore: operazione non permessa su <coll>".
stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 5 -> 2 -> 6 -> 7 -> 8 -> 3 -> NULL elimina da Coll1 l'elemento in posizione 2 stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 2 -> 6 -> 7 -> 8 -> 3 -> NULL stampa Coll4 >>Coll4 (pila di char*): "Seconda stringa" -> "Bye" -> "Hello" -> NULL elimina da Coll4 l'elemento in posizione 1 >>Errore: operazione non permessa su Coll4 elimina da Coll4 l'elemento in posizione 0 stampa Coll4 >>Coll4 (pila di char*): "Bye" -> "Hello" -> NULL
<coll> esiste in memoria ed è di tipo lista.
<num_occ>-esima occorrenza del valore <valore> in <coll> (la prima, se <num_occ> = 1, la seconda se <num_occ> = 2, etc.) viene eliminata, se esiste, e la sua memoria liberata.
Se tale elemento non esiste, la funzione non fa nulla.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è di tipo lista: "Errore: operazione non permessa su <coll>".
stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 2 -> 6 -> 7 -> 8 -> 3 -> NULL elimina da Coll1 l'occorrenza numero 2 del valore 8 stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 2 -> 6 -> 7 -> 3 -> NULL elimina da Coll1 l'occorrenza numero 2 del valore 9 stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 2 -> 6 -> 7 -> 3 -> NULL
<coll> esiste in memoria ed è di tipo lista.
<valore> in <coll> vengono eliminate, se ne esistono, e la relativa memoria viene liberata.
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è di tipo lista: "Errore: operazione non permessa su <coll>".
aggiungi a Coll1 il valore 7 stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 2 -> 6 -> 7 -> 3 -> 7 -> NULL elimina da Coll1 tutte le occorrenze del valore 7 stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 2 -> 6 -> 3 -> NULL
<coll> e <altra_coll> esistono in memoria e sono entrambe di tipo lista.
<coll> tutti i valori presenti anche nella collezione <altra_coll>, se ne esistono, e la relativa memoria viene liberata. La collezione <altra_coll> non viene modificata.
<coll> non esiste: "Errore: <coll> non esiste".
<altra_coll> non esiste: "Errore: <altra_coll> non esiste".
<coll> non è di tipo lista: "Errore: operazione non permessa su <coll>".
<altra_coll> non è di tipo lista: "Errore: operazione non permessa su <altra_coll>".
stampa Coll1 >>Coll1 (lista di int): 8 -> 9 -> 2 -> 6 -> 3 -> NULL stampa Coll5 >>Coll5 (lista di int): NULL aggiungi a Coll5 il valore 9 aggiungi a Coll5 il valore 6 stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> NULL elimina da Coll1 tutti gli elementi di Coll5 stampa Coll1 >>Coll1 (lista di int): 8 -> 2 -> 3 -> NULL
<coll> e <altra_coll> esistono in memoria e sono entrambe di tipo lista.
<coll> tutti i valori che non sono presenti anche nella collezione <altra_coll>, se ne esistono, e la relativa memoria viene liberata. La collezione <altra_coll> non viene modificata.
<coll> non esiste: "Errore: <coll> non esiste".
<altra_coll> non esiste: "Errore: <altra_coll> non esiste".
<coll> non è di tipo lista: "Errore: operazione non permessa su <coll>".
<altra_coll> non è di tipo lista: "Errore: operazione non permessa su <altra_coll>".
stampa Coll1 >>Coll1 (lista di int): 8 -> 2 -> 3 -> NULL stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> NULL aggiungi a Coll5 il valore 2 aggiungi a Coll5 il valore 3 stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> 2 -> 3 -> NULL elimina da Coll1 tutti gli elementi tranne quelli di Coll5 stampa Coll1 >>Coll1 (lista di int): 2 -> 3 -> NULL
<coll> esiste in memoria.
<coll>.
Se la lista non ha alcun elemento, viene stampato "NULL".
La collezione non viene modificata.
<coll> se esiste o "NULL" se <coll> è vuota.
Altrimenti: "Errore: <coll> non esiste".
stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> 2 -> 3 -> NULL primo elemento di Coll5 >>9 stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> 2 -> 3 -> NULL
<coll> esiste in memoria.
<coll>.
La collezione non viene modificata.
<coll> se le precondizioni sono rispettate, altrimenti: "Errore: <coll> non esiste".
stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> 2 -> 3 -> NULL lunghezza di Coll5 >>4
<coll> esiste in memoria ed è di tipo lista.
<num_occ>-esima occorrenza del valore <valore> nella collezione <coll> (la prima se <num_occ> = 1, la seconda se <num_occ> = 2, etc.). Il primo elemento della collezione ha posizione 0.
La collezione non viene modificata.
Se <coll> ha meno di <num_occ> occorrenze del valore <valore>, viene stampato "NULL".
<num_occ>-esima occorrenza di <valore> nella collezione <coll>, oppure "NULL" se <coll> ha meno di <num_occ> occorrenze del valore <valore>.
Altrimenti:
<coll> non esiste: "Errore: <coll> non esiste".
<coll> non è di tipo lista: "Errore: operazione non permessa su <coll>".
stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> 2 -> 3 -> NULL aggiungi a Coll5 il valore 6 stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> 2 -> 3 -> 6 -> NULL trova in Coll5 la posizione dell'occorrenza numero 2 del valore 6 >>4 trova in Coll5 la posizione dell'occorrenza numero 3 del valore 6 >>NULL
<coll> esiste in memoria.
<coll> viene trasformata in una collezione di tipo <tipo_coll> (che può assumere i valori lista, pila, coda). Se <coll> è già del tipo richiesto, la funzione non fa nulla.
Il contenuto della collezione non viene modificato.
Errore: <coll> non esiste".
stampa Coll5 >>Coll5 (lista di int): 9 -> 6 -> 2 -> 3 -> 6 -> NULL trasforma Coll5 in coda stampa Coll5 >>Coll5 (coda di int): 9 -> 6 -> 2 -> 3 -> 6 -> NULL aggiungi a Coll5 il valore 8 in testa >>Errore: operazione non permessa su Coll5
Arrivederci!".
esci >>Arrivederci!
Errore: comando sconosciuto".
ahhungi a Coll1 il valore 2 >>Errore: comando sconosciuto comando errato >>Errore: comando sconosciuto(Nota: la terza riga dell'esempio è composta da una sequenza di spazi seguiti dal carattere '
\n', che viene ignorata.)
a.out (Linux) oppure a.exe (Windows) legga l'input da tastiera (ad es., con istruzioni scanf()) e stampi l'output su schermo (ad es., con istruzioni printf()).
Alcuni esempi di utilizzo di I/O redirection sono i seguenti:
miofileinput.txt: "cat miofileinput.txt | ./a.out" (Linux) oppure "type miofileinput.txt | a.exe" (Windows).
miofileoutput.txt (il file viene sovrascritto se già presente): "./a.out > miofileoutput.txt" (Linux) oppure "a.exe > miofileoutput.txt" (Windows).
cat miofileinput.txt | ./a.out > miofileoutput.txt" (Linux) oppure "type miofileinput.txt | a.exe > miofileoutput.txt" (Windows).
>>".