Leggere un file usando scanf in c. Apprendimento e utilizzo delle funzioni printf() e scanf()

]SCANF #includi int scanf(format-string[[, argomento...]]); char *stringa-formato. stringa di controllo del formato. Descrizione. La funzione scanf legge i dati da flusso standard stdin nella posizione specificata dagli argomenti. Ogni argomento deve essere un puntatore a un valore con un tipo che corrisponde al tipo specificato nella stringa di formato. La stringa di formato controlla le trasformazioni dei campi di input. Questa stringa può contenere i seguenti: caratteri "Spazio", ad es. carattere spazio " ", tab \t, nuova linea"\n". Per funzioni di scansione il carattere spazio è definito per leggere, ma senza ricordare, tutti i caratteri spazio successivi inseriti fino al primo carattere non spazio. Una volta immesso, un singolo carattere spazio nella stringa di formato corrisponde a qualsiasi numero, incluso 0, o qualsiasi combinazione di caratteri spazio. Qualsiasi carattere di controllo che non sia uno spazio o un segno di percentuale %. Quindi questo carattere viene utilizzato per la funzione scanf per determinare la lettura, ma senza memorizzare i caratteri di controllo corrispondenti. Se il prossimo personaggio entra non corrisponde ai caratteri di controllo, quindi scanf termina. La specifica del formato immessa con un segno %. In questo caso, scanf legge e converte i caratteri inseriti nei valori di questo tipo e i valori sono determinati dagli argomenti corrispondenti dall'elenco di argomenti. La stringa di formato viene letta da sinistra a destra. Si presume che i caratteri al di fuori della specifica del formato siano coerenti con la sequenza di caratteri nel flusso stdin; questi caratteri corrispondenti in stdin vengono scansionati ma non ricordati. Se un carattere in stdin è in conflitto con la stringa di formato, scanf esce. Questo carattere in conflitto rimane in stdin perché non può essere letto. Quando viene rilevata la prima specifica di formato, il valore del primo campo di input viene convertito in base alla specifica di formato e memorizzato nella posizione fornita dal primo argomento. Secondo la seconda specifica di formato, il secondo campo di input viene convertito e memorizzato dal secondo argomento; e così via fino alla fine della stringa di formato. Il campo di inserimento è limitato al primo carattere "spazio bianco", ovvero al primo carattere che non può essere convertito nel formato indicato, oppure al caso di raggiungimento larghezza dei campi, che viene prima. Se vengono forniti più argomenti per la specifica del formato selezionata rispetto a quelli richiesti, gli argomenti aggiuntivi vengono ignorati. La specifica del formato ha la forma seguente. % <.precision><{F:N:h:I}>. Ciascun campo nel formato delle specifiche è un singolo carattere o numero che rappresenta un'opzione di formato diversa. Il carattere del tipo visualizzato dopo l'ultimo campo facoltativo format, definisce il tipo di campo di input come carattere, stringa o numerico. Il formato più semplice la specifica contiene solo il segno di percentuale e il carattere di tipo (ad esempio, %S). Ciascun campo della specifica del formato è descritto di seguito. Se un segno di percentuale % è seguito da un carattere che non è un carattere di controllo del formato, quel carattere e i caratteri che lo seguono, fino al successivo segno %, vengono trattati come una normale sequenza di caratteri, ad es. sequenza da inserire. Ad esempio, per inserire il carattere del segno %, viene utilizzata la combinazione %%. Un asterisco (*) dopo una % sovrascrive la designazione del campo di input successivo specificato come campo definito dal tipo di tipo. Questo campo viene scansionato ma non ricordato. Widht è un intero decimale positivo e controlla il numero massimo possibile di caratteri letti da stdin. Solo i caratteri che non superano la larghezza vengono convertiti e archiviati dall'argomento corrispondente. Se sono presenti caratteri "spazi bianchi" in larghezza, ad es. caratteri spazio, tabulazione o nuova riga, non vengono convertiti in base al formato selezionato finché non viene raggiunta la dimensione della larghezza. I prefissi opzionali F e N non tengono conto della convenzione di indirizzo predefinita dei modelli di memoria utilizzati. F può essere un prefisso di un argomento che punta a un oggetto lontano; e N - all'oggetto vicino. Il prefisso l facoltativo indica che è in uso la versione lunga; e il prefisso h - indica l'uso della versione breve. L'argomento corrispondente punta a un oggetto lungo o doppio (usando il prefisso l) oa un oggetto corto (usando il prefisso h). I modificatori l e h possono essere utilizzati insieme ai tipi di carattere d, i, o, x, u. Il modificatore l può essere utilizzato anche con i caratteri tipo e e f. Se viene specificato un altro tipo, i modificatori l e h vengono ignorati. I simboli del tipo e il loro significato sono descritti nella Tabella R.4. Tabella R.4 Tipi di caratteri Scanf CHAR INTENDED TYPE INPUT ARGUMENT TYPE d intero decimale puntatore a int. D puntatore intero decimale a long. o puntatore intero ottale a int. O puntatore intero ottale a long. x è un puntatore esadecimale a int. intero X puntatore esadecimale a long. intero i è decimale, otto è un puntatore a int. metrico o intero esadecimale I decimale, oct puntatore a long. metrico o intero esadecimale u puntatore decimale senza segno a intero numerico senza segno int. U puntatore decimale senza segno a un intero senza segno lungo. e float puntatore a un float f un punto contenente un segno opzionale ("+", "-"), una o più cifre decimali, di solito contenente un punto decimale e un esponente ("e ", "E"), che viene scritto dopo il valore intero con segno. c carattere. Quando viene specificato questo tipo, vengono letti i puntatori di caratteri a caratteri di spazio, tabulazione o nuova riga, i cosiddetti "caratteri di spazi vuoti", che di solito vengono ignorati. %1s viene utilizzato per leggere il successivo carattere diverso da spazi bianchi. stringa di s. puntatore a una matrice di caratteri sufficientemente grande per il campo di input, insieme al carattere di terminazione null "\0" che appare automaticamente. n lettura quando si immette un puntatore a un int, da stream o su quale buffer viene scritto, il numero non viene letto correttamente. caratteri specificati dal flusso o dal buffer, fino a quelli specificati nella chiamata scanf. valore p nel modulo puntatore a far- xxxx: yyyy dove si trova il gruppo di dati. le cifre xey sono cifre esadecimali maiuscole. Quando si leggono stringhe non delimitate da spazi bianchi, l'insieme di caratteri tra parentesi quadre deve essere sostituito dal tipo stringa s. Il campo di input corrispondente viene letto fino al primo carattere non contenuto nell'insieme di caratteri delimitato da parentesi quadre. Se il primo carattere di questo set è il cursore (^), il risultato viene mantenuto: il campo di input viene letto fino al primo carattere non incluso in questo set di caratteri. Per memorizzare una stringa senza il carattere nullo "\0", viene utilizzata la specifica %nc, dove n è un numero intero decimale. In questo caso, il tipo di carattere s definisce un argomento che punta a una matrice di caratteri. I successivi n caratteri vengono letti dal flusso di input nella posizione specificata e il carattere nullo non viene scritto. La funzione scanf per ogni campo di input esegue la scansione carattere per carattere. Può terminare la lettura di un singolo campo al raggiungimento di uno spazio se viene raggiunta la larghezza del campo; oppure il carattere di input successivo non può essere convertito nel formato specificato; o il carattere seguente è in conflitto con il suo carattere corrispondente in linea di controllo formato; oppure il carattere successivo non è nel set di caratteri selezionato. Quando si verifica un processo di fine lettura forzato, il campo di input successivo viene considerato dal primo carattere in conflitto. Questo carattere, se presente, viene trattato come non letto, come primo carattere del campo di input successivo o come primo carattere nelle successive operazioni di lettura stdin. Valore di ritorno. Questa funzione restituisce il numero di campi correttamente convertiti e assegnati. Il valore restituito non contiene il numero di campi letti ma non assegnati. Un tentativo di leggere la fine del file restituisce EOF. Il valore restituito 0 indica che non ci sono campi assegnati. Vedi anche fscanf, printf , sscanf , vfprintf, vprintf, vsprintf. Esempio 1. #include int io; fp galleggiante; carattere c, s; scanf("%d %f %c %s", &i, &fp, &c, s); /* inserisci vari dati */. Esempio 2. #include main() /* converte un intero esadecimale ** o ottale in ** intero decimale */ ( int numassigned, val; pintf("Inserisci esadecimale o ottale #, o 00 in guit:\n"); do ( printf("# = "); numassigned = scanf("%i", &val); printf("Decimal # = %i\n", nal); ) while (val && numassigned); /* termina il ciclo se il valore di input è 00, oppure se scanf non è in grado di assegnare il campo */.) L'output sarà il seguente. Immettere esadecimale o ottale #, o 00 per guit: # = 0xf Decimale # = 15 # = 0100 Decimale # = 64 # = 00 Decimale # = 0.

Che bello quando vengono forniti tutti i dati e non è necessario inserire nulla. Ma fidati, non è quasi mai così. Ricorda la scuola quando hai misurato determinate cose e poi hai inserito i valori ottenuti nelle formule necessarie.

scanf

Nel linguaggio C, oltre alla funzione di output printf, c'è anche funzione scanf per l'input. Ecco la funzione scanf che esamineremo ora più in dettaglio:

int io;
scanf("%d", &i);

Sembra molto simile alla funzione printf. C'è anche dentro virgolette identificatore di formato, ma la differenza è solo nella seconda parte della funzione. Prestare attenzione all'aspetto del segno (&)? Quindi questo segno significa prendere l'indirizzo. Lascia che ti spieghi perché questo è necessario.

Dobbiamo scrivere il valore inserito non da qualche parte lì, ma esattamente all'indirizzo in cui si trova la nostra variabile. Quelli. senza il segno (&), il nostro valore inserito cadrà in tutti i posti tranne quello di cui abbiamo bisogno. Pertanto, ogni volta che devi inserire valori da tastiera, fai precedere la variabile da un segno di indirizzo (&).

Identificatori di formato

1. %d - legge un numero intero

int io;
scanf("%d", &i);

2. %o - leggi numero ottale

int io;
scanf("%o", &i);

3. %x - legge il numero esadecimale

int io;
scanf("%x", &i);

4. %e(%f) - leggi il numero reale

galleggiante;
scanf("%f", &t);

5. %s - leggi il carattere

char;
scanf("%c", &ch);

6. %s - leggi la riga

carattere*str;;
scanf("%s", str);

Non approfondire ancora il lavoro con le stringhe. Perché non c'è il segno dell'indirizzo? Considereremo questo argomento un po 'più tardi.

Operazioni di confronto

Il computer era originariamente logica booleana, cioè. tutto è basato su 0 e 1. Se non capisci di cosa si tratta, riconsidera il film The Matrix, in cui ogni salvaschermo verde consisteva solo in questi due numeri magici.

Certo, 0 e 1 vanno bene, ma abbiamo bisogno di un senso logico, quindi dentro operazioni logiche 0 è FALSO e 1 è VERO. Questi concetti di VERO e FALSO sono strettamente correlati a operazioni di confronto. Per cominciare, presentiamo tutti i tipi di operazioni di confronto:

Fondamentalmente, l'errore più comune commesso dai principianti è confondere l'operatore di assegnazione (=). operazione di confronto(==). Queste sono cose completamente diverse. Ma all'inizio della codifica, tutti hanno errori su questa base, quindi fai attenzione.

Le funzioni printf() e scanf() ci danno la possibilità di interagire con il programma. Le chiamiamo funzioni I/O. Queste non sono le uniche funzioni che possiamo usare per inserire e produrre dati con i programmi C, ma sono le più versatili. Queste funzioni sono incluse nella descrizione del linguaggio C e sono fornite nella libreria stdio.h. In generale, le funzioni printf() e scanf() funzionano più o meno allo stesso modo: ciascuna utilizza una stringa di controllo e un elenco di argomenti. Esamineremo prima printf(), quindi scanf().

Le istruzioni passate alla funzione printf() quando vogliamo stampare una variabile dipendono dal tipo di variabile. Ad esempio, quando si stampa un numero intero, il formato è %d e quando si stampa un carattere è %c. I formati sono elencati nella tabella.

Ora vediamo come vengono applicati questi moduli:

/* foca */

#includere

#definisci PI 3.14159

numero int = 2003;

printf("La Internet University of Information Technology è stata aperta nell'anno %d\n", numero);

printf("Il valore di pi è %f.\n", PI);

Il formato specificato quando si chiama la funzione printf() è il seguente:

printf(Stringa di controllo, argomento1, argomento2,_);

argomento 1, argomento 2, ecc. sono parametri stampabili che possono essere variabili, costanti o anche espressioni calcolato prima della stampa.

La stringa di controllo è una stringa di caratteri che indica come devono essere stampate le opzioni. Ad esempio, nel operatore

printf("%d studenti hanno ottenuto %f.\n",

la stringa di controllo è una frase tra virgolette e numero e z sono argomenti o in questo caso i valori di due variabili.

Vediamo che la linea di controllo contiene due diversi tipi di informazioni:

Caratteri stampati testualmente.

Identificatori di dati, chiamati anche specifiche di conversione .

Ciascun argomento nell'elenco che segue la riga di controllo deve essere abbinato a uno specifica di conversione. Se è necessario stampare una frase, non è necessario utilizzarla specifica di conversione; se hai solo bisogno di stampare i dati, puoi fare a meno di usare un commento. Pertanto, ciascuno di operatori di seguito è perfettamente accettabile:

printf("Questo libro non è molto costoso!\n");

printf("%c%d\n","$",costo);

Se è necessario stampare il carattere % stesso, il compilatore lo considererà un errore specifica di conversione. La via d'uscita da questa situazione è una soluzione abbastanza semplice: scrivere due caratteri % di seguito.

Per esempio:

printf("Solo il %d%% della popolazione può imparare da solo! \n",i);

L'output del programma sarà simile a questo:

Solo il 5% della popolazione è in grado di studiare in modo indipendente!

Possiamo ampliare la definizione di base specifiche di conversione, inserendo i modificatori tra il segno % e il carattere che specifica il tipo di conversione. Quando si utilizzano più modificatori contemporaneamente, devono essere specificati nell'ordine in cui sono elencati nella tabella.

printf("/%d/\n",135);

printf("/%2d/\n",135);

printf("/%10d/\n",135);

printf("/%-10d/\n",135);

Primo specifica di conversione%d non contiene modificatori. Questa è la cosiddetta scelta di default, ovvero il risultato dell'azione del compilatore se non gli vengono fornite istruzioni aggiuntive. Secondo specifica di conversione- %2d. Specifica che la larghezza del campo deve essere 2, ma poiché il numero è di tre cifre, il campo viene automaticamente espanso alla dimensione corretta. Prossimo specifica%10d indica che la larghezza del campo è 10. L'ultimo specifica%-10d specifica anche una larghezza del campo di 10 e a - fa sì che l'intero numero venga spostato a sinistra.

La funzione scanf() è una procedura di input scopo generale A che legge i dati dal flusso stdin. Può leggere i dati di tutti tipi di base e convertirli automaticamente nel formato interno desiderato. Se printf() eseguisse l'input anziché l'output, potrebbe essere chiamato l'analogo di scanf().

La stringa di controllo a cui punta il formato è composta da tre tipi di caratteri:

• Identificatori di formato
• Simboli speciali
• Altri caratteri (non speciali)

Gli identificatori di formato seguono il segno di percentuale e indicano a scanf() quale tipo di dati leggere successivamente. I codici degli identificatori sono riportati nella tabella.

Ad esempio, %s legge una stringa e %d legge una variabile intera.

La stringa di formato viene letta da sinistra a destra, mappando i codici di formato agli argomenti nell'elenco degli argomenti.

I caratteri speciali nella stringa di controllo fanno sì che scanf() salti uno o più personaggi speciali nel flusso di input. I caratteri speciali sono spazio, tabulazione o nuova riga. Un singolo carattere speciale nella stringa di controllo fa sì che scanf() legga, senza ricordare, qualsiasi numero (incluso lo zero) di caratteri speciali consecutivi dal flusso di input finché non incontra un carattere che non è un carattere speciale.

Disponibilità carattere regolare fa in modo che scanf() legga e scarti il ​​carattere corrispondente. Ad esempio, "%d,%d" fa in modo che scanf() legga un intero, legga e scarti la virgola, quindi legga un altro intero. Se il carattere specificato non viene trovato nel flusso di input, scanf() si interrompe.

Tutte le variabili utilizzate per ricevere valori utilizzando la funzione scanf() devono essere cercate in base ai loro indirizzi. Ciò significa che tutti gli argomenti delle funzioni devono essere puntatori a variabili. Pertanto, C crea la possibilità di passare per riferimento e ciò consente alla funzione di modificare il contenuto dell'argomento.

scanf("%d", &count);

Le stringhe vengono lette in array di caratteri e il nome dell'array, senza alcun puntatore, è l'indirizzo del primo elemento dell'array. Pertanto, per leggere una stringa nella matrice di caratteri dell'indirizzo, è possibile utilizzare il comando

scanf("%s", indirizzo);

In questo caso, il nome indirizzo è già un puntatore e non necessita del prefisso &.

Gli elementi di input devono essere separati da spazi, tabulazioni o nuove righe.
I segni di punteggiatura come virgola, punto e virgola, ecc. non sono considerati separatori. Ciò significa che per l'operatore

Scanf("%d%d", &r, &c);

La sequenza 10 20 sarà accettata, ma la sequenza 10,20 no. Gli identificatori di formato scanf() sono nello stesso ordine delle variabili nell'elenco degli argomenti, a cui vengono assegnati i valori delle variabili ricevute.

Un * posizionato dopo % e prima di un identificatore di formato legge i dati del tipo specificato, ma sopprime l'assegnazione. Così il codice

Scanf("%d%*c%d", &x, &y);

Entrando nella sequenza 10/20 si assegna il valore 10 a x, si scarta la / e si assegna il valore 20 a y.

I comandi di formattazione possono specificare un modificatore larghezza massima campi. È un numero intero che viene inserito tra il segno % e l'identificatore di formato. Limita il numero di caratteri letti per ogni campo. Ad esempio, se non vuoi leggere più di 20 caratteri nell'array di indirizzi, dovresti scrivere

Scanf("%20s", indirizzo);

Se il flusso di input conteneva più di 20 caratteri, la prossima volta che la funzione di input viene chiamata, inizierà l'input dal punto in cui l'input è stato interrotto durante la chiamata corrente. L'immissione di un campo può essere interrotta prima del raggiungimento lunghezza massima campi se c'è uno spazio. In questo caso, scanf() passa al campo successivo.

Sebbene spazi, tabulazioni e nuove righe vengano utilizzati come separatori di campo, vengono letti come qualsiasi altro carattere quando viene immesso un singolo carattere. Ad esempio, dato il flusso di input x y, la funzione

Scanf("%s%s%s", &a, &b, &c);

Metti il ​​carattere x nella variabile a, lo spazio nella variabile b e y nella variabile c.

È necessario prestare attenzione: qualsiasi altro carattere nella stringa di controllo, inclusi spazi, tabulazioni e nuove righe, viene utilizzato per indicare ed eliminare i caratteri dal flusso di input. Ad esempio, con un flusso di input di 10t20, la funzione

Scanf("%st%s", &x, &y);

Mette 10 in x e 20 in y. Il carattere t verrà scartato perché nella stringa di controllo è presente una t.

Un'altra caratteristica della funzione scanf() è chiamata scan set. Il set di scansione definisce i caratteri che verranno letti dalla funzione scanf() e assegnati agli elementi dell'array di caratteri corrispondente. Per specificare un set di scansione, i caratteri il cui input è valido devono essere inseriti tra parentesi quadre. Prima del primo parentesi quadra metti il ​​segno di percentuale. Ad esempio, il seguente elenco di scan set fa sì che scanf() legga solo i caratteri A, B e C:

L'argomento dell'elenco dei set di scansione corrispondente deve essere un puntatore a una matrice di caratteri. Quando si utilizza un set di scansione, la funzione scanf() legge i caratteri e li inserisce nell'array specificato finché non incontra un carattere che non è nel set di scansione (ovvero, vengono letti solo i caratteri nel set di scansione).

L'array restituito da scanf() conterrà una stringa con terminazione null. L'elenco dei caratteri da leggere può essere specificato anche in forma inversa. Per fare ciò, metti ^ come primo carattere. Quindi scanf() accetterà qualsiasi carattere non incluso nello scan set.

Usando le virgolette, puoi specificare l'intervallo di caratteri accettati. Ad esempio, la seguente espressione dice a scanf() di accettare le lettere da "A" a "Z":

Il set di scansione distingue tra maiuscolo e minuscolo. Se vuoi che scanf() accetti entrambi, devi elencarli separatamente nello scan set.

La funzione scanf() restituisce un numero uguale al numero di campi i cui valori sono stati effettivamente assegnati alle variabili. Questo conteggio non include i campi che sono stati letti ma i loro valori non sono stati assegnati a nulla a causa dell'uso del modificatore * per sopprimere l'assegnazione. Se si è verificato un errore prima dell'assegnazione del valore del primo campo, viene restituito EOF.

Quando si utilizza Borland C++ in un ambiente a 16 bit, è possibile modificare il modello di memoria predefinito utilizzato per compilare un programma tramite indicazione esplicita la dimensione di ogni puntatore utilizzato nella chiamata scanf(). Il puntatore vicino è specificato dal modificatore N e il puntatore lontano dal modificatore F. (Non è possibile utilizzare il modificatore N se il programma è stato compilato per il modello di memoria enorme.)

La funzione scanf() è una funzione multiuso che consente di inserire qualsiasi tipo di dati nel computer. Il nome della funzione riflette il suo scopo: la funzione scansiona (esamina) la tastiera, determina quali tasti vengono premuti e quindi interpreta l'input in base ai caratteri SCAN Formattati. Proprio come la funzione printf(), scanf() può accettare più argomenti, consentendo così di inserire contemporaneamente i valori delle variabili numeriche, di carattere e di stringa.

Proprio come l'elenco dei parametri printf(), l'elenco dei parametri della funzione scanf() è composto da due parti: una stringa di formato e un elenco di dati (Figura 5.7). La stringa di formato contiene identificatori di formato, qui vengono chiamati convertitori di caratteri* che definiscono come deve essere interpretato l'input. L'elenco dei dati contiene le variabili in cui devono essere inseriti i valori di input.

Riso. 5.7. L'elenco dei parametri della funzione scanf() è diviso in due parti

Gli identificatori di formato sono simili a quelli usati dalla funzione printf():

Quando si inseriscono dati numerici o di carattere, è necessario specificare l'indirizzo della variabile nell'elenco dei dati della funzione scanf() e non solo il suo nome:

scanf("%f", &importo);

* INoriginalecaratteri di conversione.(Nota di traduzione)

In questo esempio, la funzione scanf() inserisce un numero in virgola mobile e lo memorizza nell'area di memoria riservata alla variabile importo. Non appena un numero viene posizionato in quest'area di memoria, diventa automaticamente il valore della variabile.

Mentre la funzione scanf() è in esecuzione, l'esecuzione del programma viene sospesa e il programma è in attesa di input. L'input termina con una sequenza di tasti accedere.

Il principio di lavorare con i dati della funzione scanf() è fondamentalmente diverso dal lavoro delle funzioni gets() e getchar(). Per capire esattamente cosa succede quando si entra con scanf(), è necessario esaminare in dettaglio queste differenze.

flusso di ingresso

Quando i dati vengono inseriti utilizzando la funzione gets(), tutti i caratteri che sono stati digitati sulla tastiera prima della pressione accedere, diventa il valore della variabile. Quando si immette un carattere utilizzando la funzione getchar(), premendo il tasto si assegna automaticamente il carattere corrispondente alla variabile.

La funzione scanf() funziona in modo diverso. Invece di prendere i dati e assegnarli a una variabile, scanf() utilizza principalmente identificatori di formato per determinare come devono essere trattati i caratteri di input.

È comune dire che scanf() ottiene i dati da flusso di ingresso. Un flusso di input è una sequenza di caratteri provenienti da una fonte. Nel caso della funzione scanf(), la sorgente è la tastiera. Dopo aver premuto il tasto accedere tutti i dati che sono stati inseriti finora vengono passati a scanf() come un insieme di caratteri non ancora significativo, nello stesso ordine in cui sono stati digitati. scanf() determina quindi quali caratteri corrispondono al tipo specificato dall'identificatore di formato e quali devono essere ignorati. Gli identificatori di formato sono chiamati convertitori di caratteri perché prendono i caratteri non elaborati dal flusso di input e li convertono in dati di un tipo specifico. La Figura 5.8 illustra questo processo.

La funzione scanf() ignora i caratteri non informativi: spazi, tabulazioni, newline, a meno che il tipo di dati corrente non sia char. Considera il programma:

puts("Inserisci un numero: ");

scanf("%d", &count);

printf("Il numero è %d", conteggio);

Riso. 5.8. La funzione scanf() legge il flusso di input e determina quali dati devono essere inseriti e quali devono essere ignorati.

Prima di inserire un numero, puoi premere la barra spaziatrice quanto vuoi - C ignorerà gli spazi, aspettando il primo carattere significativo. C proverà quindi a convertire i caratteri in base agli identificatori di formato nella stringa di formato scanf(). Se questi caratteri corrispondono al formato (in questo caso, se sono numeri), verranno inseriti nella variabile. L'immissione dei dati si interromperà se viene rilevato un carattere che non corrisponde al formato previsto, ovvero non è una cifra. Ad esempio, se si digita la sequenza “123abc” sulla tastiera, il numero 123 nel nostro esempio verrà assegnato alla variabile di conteggio e le lettere “abc” verranno ignorate, come mostrato nella Figura 5.9. Uno spazio può causare l'interruzione dell'immissione dei dati. Ad esempio, se si digita "123", alla variabile verrà assegnato il valore 12 e il numero 3 verrà ignorato.

Riso. 5.9. La funzione scanf() interrompe l'immissione di dati quando incontra il primo carattere non numerico.

Il primo carattere significativo deve corrispondere al formato specificato nell'argomento della funzione scanf(). Quindi, se digiti la sequenza "ABC123", il programma la ignorerà completamente e rimarrai all'oscuro del valore della variabile.

Quali caratteri il programma considera "adatti" dipende dagli specificatori di formato. Se il puntatore è %d, solo le cifre e il segno meno sono "adatti". Se inserisci il puntatore %x, i caratteri corrispondenti al formato saranno 0123456789ABCDE, poiché vengono tutti utilizzati quando si scrivono numeri nel sistema numerico esadecimale. Se il puntatore è %c, vengono accettati tutti i caratteri, anche lo spazio all'interno del flusso di input, la funzione scanf() non ignora in questo caso. Se scrivi le istruzioni:

scanf("%c", &lettera);

e premere la barra spaziatrice all'inizio della sequenza personaggi significativi, scanf() imposterà la variabile su uno spazio, ignorando i caratteri successivi. Pertanto, quando si ha a che fare con il tipo char, non è possibile mettere gli spazi prima degli altri caratteri.

Data una stringa, la funzione scanf() inizierà l'assegnazione al primo carattere significativo, ignorando gli spazi iniziali, e interromperà l'assegnazione quando incontra il primo spazio di caratteri significativo. Dai un'occhiata al programma:

puts("Inserisci il tuo nome: ");

scanf("%s", nome);

Si noti che l'operatore get address non viene utilizzato con un nome di variabile stringa. Se digiti "Nancy" sulla tastiera e premi Invio, quei caratteri verranno assegnati alla variabile del nome. Anche se si digita "Nancy Chazin", scanf() inizia l'assegnazione del carattere al primo carattere significativo e si interrompe quando incontra il primo spazio, quindi solo il nome di Nancy diventerà comunque il valore della variabile e il programma ignorerà il resto ( Figura 5.10).

Riso. 5.10. La funzione scanf() interrompe la lettura dei caratteri in una stringa quando viene visualizzato il primo spazio.

A causa di questa caratteristica della funzione scanf(), non è molto conveniente inserire stringhe. In questi casi è meglio usare la funzione gets().