Your SlideShare is downloading. ×
9   Altre Istruzioni Di I O
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

9 Altre Istruzioni Di I O

1,223
views

Published on


0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
1,223
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
45
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. INFORMATICA Altre Istruzioni di I/O
  • 2. Funzioni di I/O
    • Per la lettura e la scrittura da videoterminale il C prevede numerose istruzioni tra cui scanf e printf che, come abbiamo già visto, agiscono su tutti i tipi di dato semplici.
    •  
    • scanf e printf sono in realtà funzioni di tipo int e, come tali, ritornano un valore intero attraverso il loro nome.
    • La scanf restituisce il numero di parametri letti correttamente: se la si richiama con un unico parametro (cioè si intende leggere un solo dato), il valore restituito è 1 se la lettura è andata a buon fine, 0 in caso di errore.
    • La printf restituisce invece il numero di bytes che ha inviato in output, oppure 0 in caso di errore.
  • 3. Funzioni di I/O
    • Nel seguente frammento di programma:
    • int ndati, dato;
    • .......
    • ndati = scanf (“%d”, &dato);
    • in ndati verrebbe restituito il valore 1.
    • Nella lettura di dati da tastiera non è previsto alcun codice particolare per segnalare il fatto che i dati in ingresso sono finiti.
    •  
    • Talvolta, per questo evento, si può usare una combinazione particolare: premendo contemporaneamente i tasti CTRL (control) e Z il Sistema Operativo interpreta quella combinazione come valore particolare chiamato EOF e definito internamente).
  • 4. Esempio
    • Programma che calcola il valor medio di un certo numero di dati reali (non noto a priori) terminanti con EOF, introdotti da terminale.
    •  
    • #include <stdio.h>
    • #define VERO 1
    • #define FALSO 0
    •  
    • main()
    • {
    • double numero, somma, media;
    • int numdati, stato;
    • short int fine_lettura;
  • 5. Esempio
    • fine_lettura = FALSO; /* inizializza flag, */
    • somma = 0.0; /* accumulatore risultato */
    • numdati = 0; /* contatore dei dati introdotti */
    • printf (&quot;Introduci i dati (reali), CTRL+Z per finire: &quot;);
    • while (!fine_lettura) /* continua fino al CTRL+Z */
    • {
    • stato = scanf (&quot;%lf&quot;, &numero); /* in stato numero dati letti */
    • if (stato == 1)
    • {
    • somma += numero; /* accumula in somma */
    • numdati++; /* incrementa numdati (dati letti correttamente) */
    • }
    • else
    • fine_lettura = VERO; /* fine lettura */
    • } /* fine di while NOT fine_lettura */
  • 6. Esempio
    • if (numdati == 0)
    • printf (“ Media non calcolabile&quot;);
    • else
    • {
    • media = somma / (double)numdati;
    • printf (“ La media su %d dati e': %lf&quot;, numdati, media);
    • }
    • }
    • Oltre alla scanf e alla printf il C possiede numerose altre funzioni di lettura e scrittura sia di caratteri sia di altri tipi di dato.
  • 7. getchar()
    • Lettura di un carattere da tastiera:
    • getchar();
    • La funzione senza parametri getchar è definita in stdio.h di tipo intero ( int ) e restituisce un numero intero corrispondente al codice del tasto premuto.
    •  
    • In caso di fine file fornisce il valore particolare EOF (per la maggior parte dei sistemi vale -1) il quale è predefinito come simbolo in stdio.h .
    •  
    • Se si esclude il caso dell' EOF è lecito assegnare il valore fornito da questa funzione ad una variabile di tipo carattere ( char ).
  • 8. Esempio
    • #include <stdio.h>
    •  
    • main()
    • {
    • int carat;
    • printf (&quot;Inserisci dei caratteri, CTRL+Z per finire &quot;);
    • while ( ( carat = getchar() ) != EOF)
    • printf (&quot;%c&quot;, carat);
    • }
    • Nella condizione del while , prima è valutato l'assegnamento di getchar a carat , poi il risultato di questa operazione è confrontato con EOF .
  • 9. Input di caratteri
    • L'esecuzione di questo programma produce uno strano effetto: i caratteri appaiono sullo schermo man mano che sono introdotti; quando poi si preme <RETURN> (“invio”) viene visualizzata di nuovo tutta la riga.
    •  
    • La giustificazione sta nel fatto che la gestione fisica dell'input, è operata dal Sistema Operativo il quale legge i caratteri provenienti da tastiera, ne fa l' eco sul video e li immagazzina in un vettore interno ( buffer di tastiera ).
    •  
    • I caratteri introdotti sono trasmessi al programma solo dopo che è stato introdotto un carattere terminatore (come per esempio <RETURN> , ecc.).
  • 10. Input di caratteri
    • In questo modo si consente all'utente l'eventuale modifica della sequenza dei caratteri già introdotti fino a quando non invia un <RETURN> : questa funzionalità è nota col nome di editing di linea .
    •  
    • Le procedure interne attivate da scanf e getchar “ aspettano ” che venga introdotto un carattere terminatore (ad esempio “invio”) prima di eseguire le operazioni alle quali sono preposte.
    • Pertanto, nel programma precedente, la prima riga è l’effetto dell’eco del sistema operativo, la seconda riga è invece dovuta alla printf posta all’interno del ciclo di lettura
  • 11. putchar()
    • Visualizzazione di un carattere sul monitor:
    • putchar( <carattere> );
    • La funzione di tipo intero putchar prevede un parametro di tipo char , quello appunto che si vuole inviare al video.
    •  
    • In realtà la definizione in stdio.h rivela che il tipo carattere del parametro viene internamente convertito ad intero.
    •  
    • Il valore restituito da putchar non è interessante e coincide con il carattere stesso se l'operazione di output ha successo, altrimenti vale EOF . 
  • 12. Esempio
    • #include <stdio.h>
    •  
    • main()
    • {
    • char carat;
    • printf (&quot;Visualizzazione dei caratteri ASCII: &quot;);
    • carat = ‘ ’; /* primo carattere ASCII: spazio */
    • while (carat <= ‘ ~ ’)
    • {
    • putchar (carat);
    • carat++;
    • }
    • putchar(‘ ’); /* new-line finale */
    • }
  • 13. Confronto tra le istruzioni di I/O
    • scanf e printf sono “costruite” a partire da getchar e putchar
    • scanf e printf sono utili quando è noto il formato ( tipo ) del dato che viene letto.
    • getchar e putchar possono essere utili, anche se il loro uso non è molto semplice, quando non è noto il formato. Ad esempio: un testo in cui sono presenti spazi e punteggiatura e che pertanto non è trattabile con semplicità da scanf e printf .
  • 14. Input di testi
    • Se si deve leggere un testo (inclusi spazi e punteggiatura) la scanf non è utilizzabile e la getchar è scomoda da usare.
    • Per introdurre testi il C fornisce un’apposita istruzione, la
    • gets ( <stringa> );
    • che legge da tastiera una riga intera, compresi spazi e punteggiatura, fino all’introduzione di <RETURN> (INVIO);
    • la sequenza di caratteri letti viene trasmessa al programma sottoforma di stringa in < stringa > , senza il carattere ‘ ’.
  • 15. Input di testi
    • Poiché come al solito non ci sono controlli sugli indici, la stringa deve essere dichiarata di dimensioni opportune.
    • Non è tuttavia possibile limitare il numero di caratteri che l’utente introduce e pertanto si è esposti a eventuali danni causati dal superamento del limite del vettore.
    • La < stringa > così introdotta è una stringa a tutti gli effetti: infatti la gets inserisce il carattere di fine stringa NULL (ovvero ‘ ’).
    • Pertanto < stringa > può essere normalmente elaborata.
  • 16. Output di testi
    • Anche per visualizzare testi il C fornisce un’apposita istruzione, la
    • puts ( <stringa> );
    • che visualizza sul monitor <stringa> , aggiungendo alla fine della stringa un ‘ ’ .
    • L’istruzione
    • puts (stringa);
    • produce lo stesso output di
    • printf (“%s ”, stringa);
  • 17. I/O di testi - Esempio
    • #include <stdio.h>
    • main()
    • {
    • char riga[80];
    • printf (“Introduci una riga di testo: ”);
    • gets (riga);
    • printf (“Hai scritto: ”);
    • puts (riga);
    • }
  • 18. sprintf e sscanf
    • Importanti sono anche le due funzioni sprintf e sscanf , che operano come la printf e la scanf , effettuando una conversione pilotata da un format ; la differenza sta nel riferimento: stringa invece di stream (tastiera o monitor).
    •  
    • La sintassi di sprintf è:
    • sprintf ( <stringa>, <format>, <lista variabili> );
    •  
    • Genera in <stringa> la stessa sequenza di caratteri che genererebbe la printf sul monitor. Alla fine chiude la stringa appena generata col carattere ‘ ’ (NULL).
  • 19. sprintf e sscanf
    • Ad esempio, eseguendo il seguente frammento di programma:
    • int giorno, mese, anno;
    • char data[80];
    • ………
    • giorno = 20;
    • mese = 5;
    • anno = 2009;
    • sprintf(data,&quot;Torino %2d-%2d-%4d&quot;, giorno, mese, anno);
    • La stringa data sarà formata dalla seguente sequenza di caratteri:
    • “ Torino 20- 5-2009 ”.
  • 20. sprintf e sscanf
    • La sintassi di sscanf è:
    • sscanf ( <stringa>, <format>, <lista variabili> );
    • Le variabili della lista vengono lette interpretando i caratteri contenuti in <stringa> secondo le modalità fissate dagli specificatori di formato contenuti nel format .
    •  
    • Esempio:
    • int giorno, mese, anno;
    • char luogo[10]; char data[80] = {“Torino 20 5 2009 ”}
    • …………………………… ..
    • sscanf (data,”%s%d%d%d”, luogo, & giorno, &mese, &anno);
    • luogo vale “ Torino ” giorno vale 20 , mese vale 5 e anno vale 2009 .
  • 21. Dati sulla linea di comando
    • Abbiamo già avuto occasione di osservare come il main sia in realtà una funzione.
    • Come le altre funzioni il main è in grado di ricevere dei parametri che devono essere indicati tra le parentesi tonde che seguono la parola chiave main .
    • Per introdurre questi parametri occorre scriverli di seguito al nome del programma sulla linea di comando e separati tra loro da spazio.
    • Si tratta evidentemente di un’utile alternativa all’introduzione dei dati da tastiera.
    • Esempio:
    • bmi 72.60 175
  • 22. Dati sulla linea di comando
    • I parametri così indicati vengono passati dal sistema operativo al main tramite la seguente coppia di parametri:
    • int argc argument counter
    • char *argv[] argument vector
    • argc è una variabile intera che contiene il numero di parametri contenuti nel vettore di stringhe (matrice di caratteri) argv.
    • argv è un vettore di stringhe (matrice di caratteri).
    • Queste due variabili devo no essere dichiarate come parametri della funzione main :
    • int main (int argc, char *argv[])
  • 23. Dati sulla linea di comando
    • argc indica il numero di parametri presenti sulla riga di comando, incluso il nome del programma (pertanto vale sempre almeno 1).
    • il vettore argv[ ] (matrice di caratteri) contiene i parametri veri e propri sottoforma di stringhe secondo il seguente formato:
      • argv[0] è il nome del programma;
      • argv[n] è la stringa che rappresenta l’ ennesimo parametro dopo il nome del programma.
    • I parametri pertanto sono sempre delle stringhe : per trasformarli in rappresentazioni numeriche occorre usare le funzioni approppriate ( atoi , atol , atof ) o la sscanf .
  • 24. Dati sulla linea di comando
    • Struttura
      • Esempio: c:> programma.exe 3 pippo.dat 3.2
    argc = 4 argv[0] argv[1] argv[2] argv[3] “ programma.exe ” “ 3 ” “ pippo.dat ” “ 3.2 ”
  • 25. Dati sulla linea di comando
    • Esempio: scrivere un programma che legga sulla linea di comando due interi N e D, e visualizzi tutti i numeri minori di N che sono divisibili per D.
    • Il programma dovrà pertanto essere eseguito con il seguente comando:
    • myprog N D
    • dove myprog è il nome del programma, N e D sono i due valori richiesti per il funzionamento del programma.
  • 26. Dati sulla linea di comando
      • #include <stdio.h>
      • int main(int argc, char *argv[])
      • {
      • int N, D, i;
      • if (argc != 3)
      • {
      • printf (”Numero argomenti errato Sintassi: myprog N D”);
      • return (15);
      • }
      • N = atoi (argv[1]); /* converte N */
      • D = atoi (argv[2]); /* converte D */
      • /* oppure: sscanf (argv[1], “%d”, &N */
      • /* sscanf (argv[2], “%d”, &D */
      • for (i = 1; i < N; i++)
      • if ((i % D) == 0) printf (”%d ”, i);
      • }
    Test per verificare che l’utente ha introdotto il numero esatto di dati Converte le stringhe nella rappresentazione degli interi (compl. A 2)