Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
Lezione
set, giorno?
in corso

Input e output di caratteri

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):

istruzioneabstampa
a = getchar();111 ('o')
b = getchar();111107 ('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):

  1. si valuta l’espressione c = getchar(): legge un carattere, lo mette in c, e l’espressione vale il carattere letto;
  2. si confronta (!=) c con EOF.

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.

  1. int c; e le variabili di conteggio inizializzate a 0.
  2. while ((c = getchar()) != EOF) { ... }.
  3. Nel corpo, un if per ogni categoria di carattere: c == '\n', c >= '0' && c <= '9', c >= 'a' && c <= 'z'.
  4. Se serve ricordare qualcosa del carattere precedente (parole, spazi doppi), una variabile prec o un flag dentro aggiornato in fondo al corpo.
  5. 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:

giroK testatoK nel corpocstampa
15 vero4'c'c
24 vero3'i'i
33 vero2'a'a
42 vero1'o'o
51 vero0' '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

7Domande