[C] logica di fgets()

[MItaly]

La fgets:
- termina sempre la stringa con il NUL (= il carattere 0);
- legge tutti i caratteri dati in input fino al newline, compreso il newline a meno che il buffer che le hai passato non sia troppo corto, nel qual caso arriva a riempire fino al penultimo carattere del buffer (l'ultimo viene usato per il terminatore NUL);
- se lo stream di input termina, non verrà "inventato" alcun newline.

In pratica, fgets funziona così:

char *fgets(char *s, int size, FILE *stream) {
    int i, c;
    for(i=0; i<size-1; ++i) {
        c = getc(stream);
        if(c==EOF) break;
        s[i] = (char)c;
        if(c=='\n') break;
    }
    s[i]=0;
    if(ferror(stream) || (c==EOF && i==0)) return NULL;
    return s;
}

Per cui:
- la stringa che ottieni è sempre una stringa C valida (ovvero, è sempre terminata con il NUL);
- non vengono mai scritti caratteri oltre la dimensione che gli hai detto;
- se c'è stata tutta la riga, l'ultimo carattere sicuramente è un newline;
- se non c'è un newline in coda, o non c'è stata tutta la riga, oppure lo stream è terminato (o si è verificato un errore); puoi verificare questa condizione provando a leggere nuovamente e/o verificando lo stato dello stream con feof/ferror.

Quindi,

nome[strlen(nome)-1] = 0;

gestisce solo il caso "banale" - ovvero, c'è stato tutto e lo stream non è terminato; una gestione un po' più safe può essere:

int sz = strlen(nome);
if(sz!=0 && nome[sz-1]=='\n') nome[sz-1]=0;

- il check su sz!=0 è per essere sicuri che la stringa effettivamente contenga almeno un carattere prima di andare a vedere il penultimo carattere (modificare nome[-1] è undefined behavior);
- il check sul fatto che il penultimo carattere sia effettivamente un newline è per non perdere l'ultimo carattere se siamo alla fine dello stream
... poi se vuoi gestire correttamente input più lunghi la cosa si fa un po' più complicata e richiede l'allocazione dinamica...

[filips]

Ti ringrazio per questa bella risposta particolareggiata.

La fgets:
- legge tutti i caratteri dati in input fino al newline, compreso il newline a meno che il buffer che le hai passato non sia troppo corto, nel qual caso arriva a riempire fino al penultimo carattere del buffer (l'ultimo viene usato per il terminatore NUL);

Non ho capito bene: intendi che il buffer passato sia coerente col size e tuttavia più corto dello stream?

Quindi,

nome[strlen(nome)-1] = 0;

gestisce solo il caso "banale" - ovvero, c'è stato tutto e lo stream non è terminato

Temo che non sia esattamente questa l'intenzione dell'estensore, colpa mia per aver tagliato la nota all'esempio (ma era solo la prima parte rilevante per il mio dubbio):

Il comando dato dopo fgets() è necessario perché tale funzione legge anche ilcarattere '\n', mettendolo alla fine della stringa. Se non si vuole terminare la stringa
con un '\n' si piazza il carattere terminatore '\0' al suo posto (ovvero una posizione
prima della fine della stringa).

E comunque questa parte non mi sembrava/sembra molto chiara: il fatto che \n sia messo alla fine della stringa non sembra reggere col fatto che \0 lo rimpiazzi una posizione prima della fine della stessa. Per il resto mi sembra che volesse dire qualcosa tipo non terminare la stringa con '...\n\0', cioè se la si vuole terminare con esattamente l'ultimo carattere di input visualizzato sullo schermo.

[oregon]

La situazione mi sembra chiara ...

Un metodo (un po' "rude") per rimediare è scrivere dopo la fgets

strtok(nome, "\n");

che risolve in ogni caso.

[MItaly]

Ti ringrazio per questa bella risposta particolareggiata.
Non ho capito bene: intendi che il buffer passato sia coerente col size e tuttavia più corto dello stream?

Più corto della riga da leggere.

Temo che non sia esattamente questa l'intenzione dell'estensore, colpa mia per aver tagliato la nota all'esempio (ma era solo la prima parte rilevante per il mio dubbio):

Nah, sono abbastanza sicuro che sia come dico, è un pattern diffuso.

E comunque questa parte non mi sembrava/sembra molto chiara: il fatto che \n sia messo alla fine della stringa non sembra reggere col fatto che \0 lo rimpiazzi una posizione prima della fine della stessa. Per il resto mi sembra che volesse dire qualcosa tipo non terminare la stringa con '...\n\0', cioè se la si vuole terminare con esattamente l'ultimo carattere di input visualizzato sullo schermo.

Non capisco cosa non ti è chiaro... se vuoi accorciare la "lunghezza logica" di una stringa basta che rimpiazzi il carattere a cui vuoi farla terminare con un \0; nel caso specifico, visto che la fgets ti restituisce un \n in coda, lo rimpiazzi con un \0, in modo da farlo sparire, scorciando la stringa di un carattere.

La risposta di oregon andrebbe bene se non fosse che strtok non è né rientrante né thread-safe, per cui in linea di massima va evitata. Piuttosto, si può sfruttare la funzione (sconosciuta ai più, me compreso ) strcspn:

nome[strcspn(nome, "\n")] = 0;

(strcspn(s, reject) restituisce la lunghezza del primo segmento di s che non contiene nessuno dei caratteri di reject, che è perfetta per il nostro caso, dato che di fatto restituisce la posizione del newline o, se non è presente, del NUL finale).

[filips]

Nah, sono abbastanza sicuro che sia come dico, è un pattern diffuso.

Eppure non si faceva presente il caso di non terminazione dello stream. A me sembra che volesse dire se non si vuole che nella stringa venga inserita una andata a capo. Tu però cosa intendi esattamente con

"gestisce solo il caso "banale" - ovvero, c'è stato tutto e lo stream non è terminato"?

con "tutto" intendi fino a \n e però non si è messo lo zero? però nel primo msg avevi detto "se lo stream di input termina, non verrà "inventato" alcun newline".. non mi è chiara questa cosa

Non capisco cosa non ti è chiaro...

il fatto che dica "mettendolo alla fine della stringa" e poi affermi "ovvero una posizione
prima della fine della stringa". (Mi sembra che non abbia senso dire che \n sta alla fine se subito dopo si ammette che \0 la rimpiazza una posizione prima della fine; al limite poteva avere senso dire che piazzando lo zero al posto di \n, la stringa finiva una posizione prima della precedente.)

[MItaly]

Eppure non si faceva presente il caso di non terminazione dello stream.

Appunto, è per quello che dico che è incompleta, funziona correttamente nel caso "banale" in cui lo stream non è terminato.

A me sembra che volesse dire se non si vuole che nella stringa venga inserita una andata a capo.

Appunto-bis, vuole rimuovere l'a-capo che viene letto dalla fgets; il punto che dico è che non tiene conto che ci sono alcuni casi in cui questo a-capo non viene messo, che lui non gestisce.

Tu però cosa intendi esattamente con

"gestisce solo il caso "banale" - ovvero, c'è stato tutto e lo stream non è terminato"?

con "tutto" intendi fino a \n e però non si è messo lo zero? però nel primo msg avevi detto "se lo stream di input termina, non verrà "inventato" alcun newline".. non mi è chiara questa cosa

None! Intendo dire che gli hai passato un buffer lungo a sufficienza per leggere tutta la riga, newline compreso (e NUL compreso, che viene sempre messo), e che lo stream non è terminato, ovvero l'utente non ha premuto Ctrl-D (o Ctrl-Z su Windows) o, se l'input è stato rediretto da file, il file non è terminato. Non viene gestito invece il caso di stream terminato (cosa che capita sempre se si sta leggendo da file o in generale lo standard input è stato rediretto).

il fatto che dica "mettendolo alla fine della stringa" e poi affermi "ovvero una posizione
prima della fine della stringa". (Mi sembra che non abbia senso dire che \n sta alla fine se subito dopo si ammette che \0 la rimpiazza una posizione prima della fine; al limite poteva avere senso dire che piazzando lo zero al posto di \n, la stringa finiva una posizione prima della precedente.)

È solo una confusione di terminologia. La stringa finisce dove sta il NUL. Se non c'è un NUL, non è una stringa C e non ha senso parlare di fine della stringa (esistono le stringhe counted, ma è un altro paio di maniche). Se rimpiazzi un carattere che attualmente sta prima del NUL con un NUL, la stringa si accorcia, troncando via il carattere che hai sostituito e tutti quelli che lo seguivano.