Argomento di Programmazione 1. Fatto a lezione a settembre, deck 3.2: slide 58-68. Usa il while di Ciclo while ed esempi e i codici ASCII di Espressioni, operatori e costanti.
Il filo del deck:
stdin, stdout sequenze di caratteri, buffer del SO in mezzo slide 58-59
|
getchar, putchar un carattere alla volta, c è int slide 60
|
copia K caratteri while (K--) gira K volte slide 61-62
|
copia fino a EOF pseudocodice, poi codice con EOF slide 63-64
|
forma compatta while ((c = getchar()) != EOF), in due passi slide 65-66
|
conta i caratteri contatore dentro il ciclo di lettura slide 67-68
1Definizioni
Standard input e output a caratteri (slide 59). getchar e putchar sono “funzioni utili per elaborazioni di caratteri in uscita ed ingresso” sullo standard input (di solito la tastiera) e sullo standard output (di solito lo schermo). Si possono vedere come sequenze di caratteri, uno dopo l’altro. Nel disegno della slide, fra la tastiera e lo schermo e la memoria ci sono due buffer gestiti dal sistema operativo: i caratteri digitati si accumulano lì, e di solito arrivano al programma solo quando premi Invio. Per questo un programma che legge un carattere alla volta sembra “aspettare” la fine della riga.
getchar() (slide 60). “Legge il prossimo carattere da standard input e lo restituisce.” Ogni chiamata consuma un carattere: un carattere letto non si rilegge.
c = getchar(); c conterrà il carattere letto
putchar(c). “Stampa il carattere c su standard output.”
putchar(c);
Entrambe sono in stdio.h. Anche l’a capo '\n' e lo spazio sono caratteri: getchar li restituisce come gli altri, e putchar('\n') va a capo.
Esempio 1, leggere due caratteri e scambiarli. Un carattere è un numero (il suo codice ASCII), e printf con %d lo mostra:
#include <stdio.h>
int main(void)
{
int a;
int b;
a = getchar();
b = getchar();
putchar(b);
putchar(a);
putchar('\n');
printf("%d %d\n", a, b);
return 0;
}
Con input ok (printf 'ok' | ./a.out):
| istruzione | a | b | stampa |
|---|---|---|---|
a = getchar(); | 111 ('o') | ||
b = getchar(); | 111 | 107 ('k') | |
putchar(b); | k | ||
putchar(a); | o | ||
putchar('\n'); | a capo | ||
printf(...) | 111 107 |
Output (verificato): ko, poi 111 107.
Esempio 2, cosa restituisce getchar quando non c’è più niente:
#include <stdio.h>
int main(void)
{
int c;
printf("EOF vale %d\n", EOF);
c = getchar();
printf("primo getchar: %d\n", c);
c = getchar();
printf("secondo getchar: %d\n", c);
return 0;
}
Con input A (printf 'A' | ./a.out) stampa EOF vale -1, primo getchar: 65, secondo getchar: -1 (verificato): il primo legge la A, il secondo trova l’input finito. Con input vuoto anche il primo dà -1.
EOF (slide 64). “EOF segnala «fine del file». Costante int definita in stdio.h”, e il commento del prof nel codice aggiunge: “il valore non importa”. getchar lo restituisce quando l’input è finito (end of file). Vale -1 con gcc, ma si confronta sempre con il nome EOF. Da tastiera la fine dell’input si segnala con Ctrl+D su Linux e macOS (a inizio riga), con Ctrl+Z e Invio su Windows, quindi anche in Dev-C++. Se l’input arriva da un file o da una pipe, EOF arriva da solo alla fine.
Perché int c e non char c (slide 60). La slide: “c deve essere una variabile dichiarata int perché getchar restituisce un valore di tipo int e putchar richiede una variabile di tipo int”. Il motivo: getchar deve poter restituire tutti i 256 valori di un byte più un valore in più, EOF, che non è nessun carattere. Un char ha solo 256 valori, quindi EOF finirebbe confuso con un carattere vero. Il commento del prof nel codice: c è “intero ma ANCHE un carattere”.
Controesempio, con char c:
#include <stdio.h>
int main(void)
{
char c;
int n = 0;
while ((c = getchar()) != EOF) {
n++;
}
printf("letti %d caratteri\n", n);
return 0;
}
Con input abcd stampa letti 4 caratteri, giusto. Con input ab, un byte di valore 255, poi cd (printf 'ab\xffcd' | ./a.out) stampa letti 2 caratteri (verificato): su gcc per PC char ha segno, il byte 255 messo in un char diventa -1, uguale a EOF, e il ciclo si ferma a metà. Dove char è senza segno succede il contrario: c non vale mai -1, il confronto con EOF non è mai vero e il ciclo non finisce. gcc non avvisa: l’errore si vede solo a runtime.
2Concetti
2.1Il ciclo di lettura fino a EOF
È il pattern della sentinella di Ciclo while ed esempi, con EOF come sentinella. Pseudocodice della slide 63:
leggi un carattere
while (non è fine file) {
stampa il carattere appena letto
leggi il prossimo carattere
}
Forma compatta (slide 65-66), “versione che consolida getchar nella condizione del while”: lettura e controllo nella stessa condizione.
while ((c = getchar()) != EOF) {
putchar(c);
}
La condizione si valuta in due passi (slide 66):
- si valuta l’espressione
c = getchar(): legge un carattere, lo mette inc, e l’espressione vale il carattere letto; - si confronta (
!=)cconEOF.
Funziona perché un’assegnazione è un’espressione con un valore, visto in Il Linguaggio C. Il corpo vede il carattere appena letto, e la riga “leggi il prossimo” in fondo al corpo sparisce: la fa la condizione al giro dopo.
Le parentesi sono obbligatorie. != ha precedenza più alta di =. Senza parentesi, c = getchar() != EOF si legge c = (getchar() != EOF): c riceve 1 finché l’input non è finito, e il programma stampa il carattere di codice 1 invece di quello letto.
while (c = getchar() != EOF) {
putchar(c + '0');
}
Con input abc stampa 111 (verificato): c vale 1 a ogni giro, e 1 + '0' è il carattere '1'. gcc con -Wall avvisa (suggest parentheses around assignment used as truth value).
Esempio 1, contare spazi e righe. Due if indipendenti nel corpo, uno per categoria:
#include <stdio.h>
int main(void)
{
int c;
int spazi = 0;
int righe = 0;
while ((c = getchar()) != EOF) {
if (c == ' ')
spazi++;
if (c == '\n')
righe++;
}
printf("spazi=%d righe=%d\n", spazi, righe);
return 0;
}
Con input la scala a capo ha 7 gradini a capo (printf 'la scala\nha 7 gradini\n' | ./a.out): uno spazio nella prima riga, due nella seconda, due \n. Output (verificato): spazi=3 righe=2.
Esempio 2, trasformare mentre si copia: ogni cifra diventa #, il resto passa invariato. Un carattere è una cifra se il suo codice sta fra quello di '0' e quello di '9', che in ASCII sono consecutivi.
#include <stdio.h>
int main(void)
{
int c;
while ((c = getchar()) != EOF) {
if (c >= '0' && c <= '9')
putchar('#');
else
putchar(c);
}
return 0;
}
Con input tel 0461 28 a capo stampa tel #### ## e l’a capo (verificato). Lo spazio e \n non sono cifre, quindi passano.
2.2Aritmetica sui caratteri
Siccome un carattere è il suo codice, si può fare aritmetica: in ASCII le lettere minuscole sono consecutive ('a' = 97, …, 'z' = 122), così le maiuscole ('A' = 65) e le cifre ('0' = 48).
c - '0' da cifra a valore: '7' - '0' = 55 - 48 = 7
c - 'a' posizione nell'alfabeto: 'c' - 'a' = 2
c - 'a' + 'A' da minuscola a maiuscola: 'c' - 'a' + 'A' = 2 + 65 = 67 = 'C'
c + 1 il carattere dopo: 'H' + 1 = 'I'
Le formule si scrivono con i caratteri fra apici, non con i numeri: c - 'a' + 'A' si legge e non dipende dal ricordarsi 97 e 65.
3Metodo
Programma che elabora l’input carattere per carattere.
int c;e le variabili di conteggio inizializzate a 0.while ((c = getchar()) != EOF) { ... }.- Nel corpo, un
ifper ogni categoria di carattere:c == '\n',c >= '0' && c <= '9',c >= 'a' && c <= 'z'. - Se serve ricordare qualcosa del carattere precedente (parole, spazi doppi), una variabile
preco un flagdentroaggiornato in fondo al corpo. - Dopo il ciclo, stampa i risultati.
Tracciare su un input dato. Scrivi l’input carattere per carattere, compresi spazi e \n, e fai una riga di tabella per carattere. Controlla se l’input finisce con \n o no: cambia il conteggio delle righe e dei caratteri. Ogni getchar nel corpo consuma un carattere in più: contali.
4Esempi svolti a lezione
Copia dei primi K caratteri (slide 61-62). Esercizio della slide 61: “copiare l’input e restituirlo in output per i primi K caratteri”.
#include <stdio.h>
int main(void)
{
int K = 5;
int c;
while (K--) {
c = getchar();
putchar(c);
}
return 0;
}
Con input ciao mondo:
| giro | K testato | K nel corpo | c | stampa |
|---|---|---|---|---|
| 1 | 5 vero | 4 | 'c' | c |
| 2 | 4 vero | 3 | 'i' | i |
| 3 | 3 vero | 2 | 'a' | a |
| 4 | 2 vero | 1 | 'o' | o |
| 5 | 1 vero | 0 | ' ' | spazio |
| 0 falso | -1 |
while (K--) gira esattamente 5 volte, e all’uscita K vale -1. Output (verificato): ciao (cinque caratteri, lo spazio compreso). mondo resta nel buffer e non viene letto.
Il programma non controlla EOF. Se l’input ha meno di 5 caratteri, dopo la fine getchar restituisce EOF e putchar(EOF) stampa un byte spazzatura (con input ab escono a, b e tre byte di valore 255: verificato con od). La correzione è uscire anche a fine input: while (K-- && (c = getchar()) != EOF) putchar(c);.
Copia dell’input sull’output (slide 63-64). Pseudocodice della slide 63: leggi un carattere alla volta; finché non è fine file, stampa il carattere appena letto e leggi il prossimo carattere. Il codice della slide 64 è la traduzione riga per riga:
#include <stdio.h>
int main(void)
{
int c;
c = getchar();
while (c != EOF) {
putchar(c);
c = getchar();
}
printf("Fine \n");
return 0;
}
Con input ciao mondo a capo: il primo getchar legge c, il ciclo stampa e rilegge per ognuno degli 11 caratteri (10 di ciao mondo più \n), al dodicesimo getchar arriva EOF e si esce. Output (verificato): ciao mondo, a capo, Fine (con lo spazio prima di \n, come nella slide). Gli a capo passano come caratteri normali.
Versione aggiornata (slide 65-66), con getchar nella condizione. Stesso output (verificato):
#include <stdio.h>
int main(void)
{
int c;
while ((c = getchar()) != EOF) {
putchar(c);
}
printf("Fine \n");
return 0;
}
Contare i caratteri (slide 67-68). Pseudocodice: leggi un carattere alla volta; finché non è fine file aggiorna il contatore caratteri e leggi il prossimo carattere; stampa il numero di caratteri. Nel codice il fumetto indica ++nc come “aggiornamento contatore caratteri”.
#include <stdio.h>
int main(void)
{
int c;
int nc = 0;
while ((c = getchar()) != EOF) {
++nc;
putchar(c);
}
printf("\nNumero Caratteri=%d\n", nc);
return 0;
}
Con input ciao mondo a capo: 10 caratteri più \n fanno 11. Stampa la riga copiata, una riga vuota (il \n dell’input più quello all’inizio del printf) e Numero Caratteri=11 (verificato). Con input ciao a capo conta 5; con input vuoto stampa una riga vuota e Numero Caratteri=0. ++nc e nc++ qui sono uguali, perché il valore dell’espressione non si usa. Sulla slide il printf finale è "\nNumero Caratteri=%d", senza \n in fondo; qui è aggiunto perché il prompt della shell non finisca attaccato al numero.
5Esercizi tipo esame
In una pagina a parte, dal più facile al livello del 30: Input e output di caratteri (esercizi).
6Errori tipici
char c;per il risultato digetchar: il confronto con EOF può non funzionare (si ferma al byte 255, o non si ferma mai).- Dimenticare le parentesi:
c = getchar() != EOFmette incil risultato del confronto. - Chiamare
getchar()due volte nello stesso giro (una nella condizione e una nel corpo): ogni chiamata consuma un carattere, quindi metà dei caratteri si perde. - Dimenticare che
'\n'è un carattere: un programma che conta i caratteri diciaoa capo ne conta 5. - Confrontare con
'EOF'o con"EOF": EOF è una costante intera, si scrive senza apici. - Usare i numeri dei codici (
c - 97 + 65) invece dei caratteri (c - 'a' + 'A'): funziona, ma si sbaglia facilmente e non si legge. - Confondere
'0'(il carattere, codice 48) con0(il numero):somma += csenza- '0'somma i codici. - Non controllare EOF in un ciclo che legge un numero fisso di caratteri: a input finito
putchar(EOF)stampa spazzatura. - Aspettarsi che il programma reagisca a ogni tasto: il buffer del sistema operativo passa i caratteri a riga completata.
7Domande
-
Cosa fanno
getchar()eputchar(c)? -
Cos’è
EOF, dove è definito e come si genera da tastiera? -
Perché la variabile che riceve il risultato di
getcharva dichiarataint? -
In che ordine si valuta
(c = getchar()) != EOF? -
Cosa succede se si scrive
c = getchar() != EOFsenza parentesi? -
Scrivi il ciclo che copia tutto lo standard input sullo standard output.
-
Quanti caratteri conta il programma della slide 68 con input
ciaoseguito da a capo? -
Con
K = 5, quante volte girawhile (K--)e quanto valeKalla fine? -
Come si trasforma una minuscola in maiuscola usando i codici ASCII?
-
Cos’è il buffer dello standard input e che effetto ha su un programma che usa
getchar? -
Come si ottiene il valore numerico di una cifra letta con
getchar? -
Cosa succede al programma della slide 62 se l’input ha meno di K caratteri, e come si corregge?