scanf () - Leggi dati
Formato
#include <stdio.h>
int scanf(const char *format-string, argument-list);Livello lingua
ANSI
Protetto dal sottoprocesso
Sì
Sensibile alla locale
Il funzionamento di questa funzione potrebbe essere influenzato dalle categorie LC_CTYPE e LC_NUMERIC della locale corrente. Il comportamento potrebbe essere influenzato anche dalla categoria LC_UNI_CTY della locale corrente se LOCALETYPE (*LOCALEUCS2) o LOCALETYPE (*LOCALEUTF) viene specificato nel comando di compilazione. Per ulteriori informazioni, consultare Descrizione dei CCSID e delle locale.
Descrizione
La funzione scanf() legge i dati dal flusso di immissione standard stdin nelle posizioni fornite da ciascuna voce in argument - list. Ogni argomento deve essere un puntatore a una variabile con un tipo che corrisponde a uno specificatore di tipo in stringa - formato. format - string controlla l'interpretazione dei campi di immissione ed è una stringa di caratteri multibyte che inizia e termina nello stato di spostamento iniziale.
- I caratteri spazio, come specificato dalla funzione
isspace()(come gli spazi e i caratteri di nuova riga). Un carattere spazio vuoto fa sì che la funzionescanf()legga, ma non memorizzi, tutti i caratteri spazio vuoto consecutivi nell'input fino al carattere successivo che non è uno spazio vuoto. Un carattere spazio vuoto in format - string corrisponde a qualsiasi combinazione di caratteri spazio vuoto nell'input. - Caratteri che non sono spazi vuoti, ad eccezione del carattere di percentuale (%). Un carattere non spazio fa sì che la funzione
scanf()legga, ma non memorizzi, un carattere non spazio corrispondente. Se il carattere successivo instdinnon corrisponde, la funzionescanf()termina. - Specifiche di formato, introdotte dal segno percentuale (%). Una specifica di formato fa sì che la funzione
scanf()legga e converta i caratteri nell'input in valori di un tipo specificato. Il valore viene assegnato ad un argomento nell'elenco di argomenti.
La funzione scanf() legge format - string da sinistra a destra. I caratteri al di fuori delle specifiche di formato devono corrispondere alla sequenza di caratteri in stdin; i caratteri corrispondenti in stdin vengono scansionati ma non memorizzati. Se un carattere in stdin è in conflitto con format - string, scanf() termina. Il carattere in conflitto viene lasciato in stdin come se non fosse stato letto.
Quando viene trovata la prima specifica di formato, il valore del primo campo di input viene convertito in base alla specifica di formato e memorizzato nella posizione specificata dalla prima voce in argument - list. La seconda specifica di formato converte il secondo campo di input e lo memorizza nella seconda voce in argument - liste così via fino alla fine di format - string.
Un campo di input viene definito come tutti i caratteri fino al primo carattere spazio vuoto (spazio, tabulazione o nuova riga), fino al primo carattere che non può essere convertito in base alla specifica del formato o fino a quando non viene raggiunto il campo larghezza , a seconda di quale si verifica per primo. Se ci sono troppi argomenti per le specifiche di formato, gli argomenti supplementari vengono ignorati. I risultati non sono definiti se non vi sono argomenti sufficienti per le specifiche di formato.
Una specifica di formato ha il seguente formato:
Ogni campo della specifica di formato è un singolo carattere o un numero che indica una particolare opzione di formato. Il carattere tipo , che viene visualizzato dopo l'ultimo campo di formato facoltativo, determina se il campo di input viene interpretato come un carattere, una stringa o un numero. La specifica di formato più semplice contiene solo il segno di percentuale e un carattere tipo (ad esempio, %s).
Ogni campo della specifica di formato viene discusso in dettaglio di seguito. Se un segno di percentuale (%) è seguito da un carattere che non ha alcun significato come carattere di controllo del formato, il comportamento non è definito. Un'eccezione a questo comportamento è %%. Per specificare un carattere di segno percentuale, utilizzare %%.
- Se un puntatore viene stampato e riscannerizzato dallo stesso gruppo di attivazione, il puntatore riscannerizzato verrà confrontato con il puntatore che viene stampato.
- Se una funzione della famiglia
scanf()esegue la scansione di un puntatore stampato da un diverso gruppo di attivazione, la funzione della famigliascanf()imposterà il puntatore su NULL.
Consultare il manuale ILE C/C++ Programmer's Guide per ulteriori informazioni sull'utilizzo dei puntatori IBM® i .
Un asterisco (*) dopo il segno percentuale elimina l'assegnazione del campo di input successivo, che viene interpretato come un campo del tipospecificato. Il campo è sottoposto a scansione ma non è memorizzato.
La larghezza è un numero intero decimale positivo che controlla il numero massimo di caratteri da leggere da stdin. Non più di larghezza caratteri vengono convertiti e memorizzati nell' argomentocorrispondente. Vengono letti meno di larghezza caratteri se un carattere di spazio (spazio, tabulazione o nuova riga) o un carattere che non può essere convertito in base al formato fornito si verifica prima che venga raggiunta la larghezza .
I modificatori di dimensione facoltativi h, l, ll, L, H, D e DD indicano la dimensione dell'oggetto ricevente. I caratteri di conversione d, i e n devono essere preceduti da h se l'argomento corrispondente è un puntatore a un int breve piuttosto che un puntatore a un int, da l se è un puntatore a un int lungo o da ll se è un puntatore a un int lungo. Analogamente, i caratteri di conversione o, u, x e X devono essere preceduti da h se l'argomento corrispondente è un puntatore a un int breve senza segno piuttosto che un puntatore a un int senza segno, da l se è un puntatore a un int lungo senza segno o da ll se è un puntatore a un long long senza segno. I caratteri di conversione a, A, e, E, f, F, g e G devono essere preceduti da l se l'argomento corrispondente è un puntatore a un valore doppio piuttosto che un puntatore a un valore mobile, da L se è un puntatore a un valore doppio lungo, da H se è un puntatore a un valore _Decimal32, da D se è un puntatore a un valore _Decimal64o da DD se è un puntatore a un valore _Decimal128. Infine, i caratteri di conversione c, s e [ devono essere preceduti da l se l'argomento corrispondente è un puntatore a un wchar_t piuttosto che un puntatore a un tipo di carattere a byte singolo. Se un carattere h, l, L, ll, H, D o DD viene visualizzato con qualsiasi altro carattere di conversione, il comportamento non è definito.
I caratteri type e i loro significati sono riportati nella tabella seguente:
| Carattere | Tipo di input previsto | Tipo di argomento |
|---|---|---|
| g | Numero intero decimale con segno | Puntatore a int. |
| o | Numero intero ottale senza segno | Puntatore a int senza segno. |
| x, X | Numero intero esadecimale senza segno | Puntatore a int senza segno. |
| i | Numero intero decimale, esadecimale o ottale | Puntatore a int. |
| a | Numero intero decimale senza segno | Puntatore a int senza segno. |
| a, A, e, E, f, F, g, G | Per i numeri in virgola mobile non decimali, un numero in virgola mobile con segno opzionale, l'infinito o NaN, il cui formato è lo stesso previsto per la funzione strtod(). Per i numeri decimali in virgola mobile, un numero in virgola mobile con segno opzionale, l'infinito o NaN, il cui formato è lo stesso previsto per la funzione strtod64(). |
Puntatore a virgola mobile. |
| D (n, p) | Valore decimale compresso costituito da un segno facoltativo (+ o -); quindi una sequenza non vuota di cifre, facoltativamente una serie di una o più cifre decimali contenenti probabilmente una virgola decimale, ma non un suffisso decimale. La sequenza del soggetto è definita come la sottosequenza iniziale più lunga della stringa di input, che inizia con il primo carattere non spazio, nel formato previsto. Non contiene caratteri se la stringa di input è vuota o è composta interamente da uno spazio vuoto o se il primo carattere non spazio è diverso da un segno, da una cifra o da un carattere di virgola decimale. | Puntatore a decimal (n, p). Poiché la rappresentazione interna dell'oggetto decimale codificato binario è uguale alla rappresentazione interna del tipo di dati decimale compresso, è possibile utilizzare il carattere di tipo D (n, p). |
| c | Carattere; i caratteri spazio che vengono normalmente ignorati vengono letti quando si specifica c | Puntatore al carattere abbastanza grande per il campo di input. |
| s | Stringa | Puntatore alla schiera di caratteri abbastanza grande per il campo di immissione più un carattere null finale (\0), che viene aggiunto automaticamente. |
| n | Nessun input letto dal flusso o buffer | Puntatore a int, in cui viene memorizzato il numero di caratteri letti correttamente dal flusso o dal buffer fino a quel punto nella chiamata a scanf(). |
| p | Puntatore a void convertito in serie di caratteri | Puntatore a void. |
| lc | Costante carattere multibyte | Puntatore a wchar_t. |
| ls | Costante stringa multibyte | Puntatore alla stringa wchar_t. |
Per leggere le stringhe non delimitate da spazi, sostituire una serie di caratteri tra parentesi ([]) per il carattere di tipo (stringa). Il campo di input corrispondente viene letto fino al primo carattere che non compare nella serie di caratteri tra parentesi. Se il primo carattere nell'insieme è un accento circonflesso (^), l'effetto viene invertito: il campo di input viene letto fino al primo carattere che appare nel resto dell'insieme di caratteri.
Per memorizzare una stringa senza memorizzare un carattere null finale (\0), utilizzare la specifica %ac, dove a è un numero intero decimale. In questa istanza, il carattere di tipo c significa che l'argomento è un puntatore a una schiera di caratteri. I successivi caratteri a vengono letti dal flusso di input nell'ubicazione specificata e non viene aggiunto alcun carattere null.
L'input per uno specificatore formato %x viene interpretato come un numero esadecimale.
La funzione scanf() esegue la scansione di ogni campo di input carattere per carattere. Potrebbe interrompere la lettura di un particolare campo di input prima che raggiunga un carattere spazio, quando viene raggiunta la larghezza specificata o quando il carattere successivo non può essere convertito come specificato. Quando si verifica un conflitto tra la specifica e il carattere di input, il successivo campo di input inizia dal primo carattere non letto. Il carattere in conflitto, se presente, viene considerato non letto ed è il primo carattere del campo di input successivo o il primo carattere nelle successive operazioni di lettura su stdin.
Per %lc e %ls, specifica che i dati letti sono una stringa multibyte e vengono convertiti in caratteri estesi come se fossero chiamate a mbtowc.
Per gli specificatori di formato %a, %A, %e, %E, %f, %F, %ge %G, una sequenza di caratteri diINFINITYoppureNAN(ignorando il maiuscolo / minuscolo) è consentito e restituisce un valore di INFINITY o Quiet Not - A - Number (NaN), rispettivamente.
In alternativa, è possibile assegnare voci specifiche nell'elenco di argomenti utilizzando la specifica del formato indicata nel diagramma precedente. Questa specifica di formato e la specifica di formato precedente non possono essere combinate nella stessa chiamata a scanf(). In caso contrario, potrebbero verificarsi risultati imprevedibili.
L'arg - number è una costante intera positiva dove 1 fa riferimento alla prima voce nell'elenco di argomenti. Il numero di argomenti non può essere maggiore del numero di voci nell'elenco di argomenti oppure i risultati non sono definiti. Anche Arg - number non può essere maggiore di NL_ARGMAX.
Valore restituito
La funzione scanf() restituisce il numero di campi che sono stati convertiti e assegnati correttamente. Il valore di ritorno non comprende i campi che sono stati letti ma non assegnati.
Il valore di ritorno è EOF per un tentativo di lettura alla fine del file se non è stata eseguita alcuna conversione. Un valore di ritorno 0 indica che non sono stati assegnati campi.
Condizioni di errore
Se il tipo di argomento a cui deve essere assegnato è diverso dalla specifica del formato, possono verificarsi risultati imprevedibili. Ad esempio, la lettura di un valore a virgola mobile, ma l'assegnazione in una variabile di tipo int, non è corretta e avrebbe risultati imprevedibili.
Se ci sono più argomenti che specifiche di formato, gli argomenti supplementari vengono ignorati. I risultati non sono definiti se non vi sono argomenti sufficienti per le specifiche di formato.
Se la stringa di formato contiene una specifica di formato non valida e vengono utilizzate specifiche di formato posizionali, errno verrà impostato su EILSEQ.
Se vengono utilizzate specifiche di formato posizionale e non vi sono argomenti sufficienti, errno verrà impostato su EINVAL.
Se si verifica un errore di conversione, errno può essere impostato su ECONVERT.
Esempi
#include <stdio.h>
int main(void)
{
int i;
float fp;
char c, s[81];
printf("Enter an integer, a real number, a character "
"and a string : \n");
if (scanf("%d %f %c %s", &i, &fp, &c, s) != 4)
printf("Not all fields were assigned\n");
else
{
printf("integer = %d\n", i);
printf("real number = %f\n", fp);
printf("character = %c\n", c);
printf("string = %s\n",s);
}
}
/***************** If input is: 12 2.5 a yes, *******************
************** then output should be similar to: ****************
Enter an integer, a real number, a character and a string :
integer = 12
real number = 2.500000
character = a
string = yes
*/#include <stdio.h>
int main(void)
{
int number;
printf("Enter a hexadecimal number or anything else to quit:\n");
while (scanf("%x",&number))
{
printf("Hexadecimal Number = %x\n",number);
printf("Decimal Number = %d\n",number);
}
}
/*************** If input is: 0x231 0xf5e 0x1 q, ****************
**************** then output should be similar to: **************
Enter a hexadecimal number or anything else to quit:
Hexadecimal Number = 231
Decimal Number = 561
Hexadecimal Number = f5e
Decimal Number = 3934
Hexadecimal Number = 1
Decimal Number = 1
*/stdin e assegna i dati utilizzando la stringa di formato posizionale alternativa.#include <stdio.h>
int main(int argc, char *argv[])
{
int i;
char s[20];
float f;
scanf("%2$s %3$f %1$d",&i, s, &f);
printf("The data read was \n%i\n%s\n%f\n,i,s,f);
return 0;
}
/*************** If the input is : test 0.2 100 *****************
************** then the output will be similar to: ***************
The data read was
100
test
0.20000
*/
-------------------------------------------------------------------- #include <locale.h>
#include <stdio.h>
#include <wchar.h>
void main(void)
{
wchar_t uString[20];
setlocale(LC_UNI_ALL, "");
scanf("Enter a string %ls",uString);
printf("String read was %ls\n",uString);
}
/* if the input is : ABC
then the output will be similiar to:
String read was ABC
*/Informazioni correlate
- fscanf () - Leggi dati formattati
- printf () - Stampa caratteri formattati
- sscanf () - Leggi dati
- strtod () - strtof () - strtold () - Conversione della stringa di caratteri in Double, Float e Long Double
- strtod32() - strtod64() - strtod128() - Converti stringa di carattere in virgola mobile decimale
- wscanf () - Leggi i dati utilizzando la stringa in formato di caratteri esteso
- fwscanf () - Leggi i dati dal flusso utilizzando il carattere esteso
- swscanf () - Lettura dati carattere esteso
- <stdio.h>