Descrizione della funzione Scanf C.

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.

Si prega di mettere in pausa AdBlock su questo sito.

Torniamo all'ultimo elenco dell'ultimo passaggio:

Listato 1.

#includere int main(void) ( int a, b, res; a = 10; b = 7; res = a + b; printf("%d + %d = %d\n", a, b, res); return 0;)

Il compito principale di questo passaggio è imparare come ottenere i dati dall'utente.

È possibile utilizzare la funzione scanf per questo. Come la funzione printf, è descritta in file di intestazione stdio.h Perché lo abbiamo già collegato nella prima riga, quindi possiamo usare liberamente la funzione scanf nel nostro programma.

Fig. 1. La sintassi generale della funzione scanf.

Le virgolette doppie indicano l'identificatore di formato. A seconda di quale variabile memorizzeremo il valore inserito, è necessario utilizzare l'identificatore di formato appropriato.

Identificatori di formato di base:

%d- numeri interi
%f- numero reale tipo galleggiante
%lf- numero reale digita doppio(notazione lf da float lungo)
%c- simbolo

Si noti che la funzione scanf utilizza identificatori di formato diversi per i tipi float e double.

Dopo la format-string, devi specificare l'indirizzo della variabile in cui vuoi salvare i dati. Per specificare l'indirizzo di una variabile è sufficiente scrivere il segno & (e commerciale) prima del suo nome, come nella figura sopra.

Scriviamo, infine, un programma per sommare due numeri.

Listato 2.

#includere int main(void) ( int a, b, res; scanf("%d", &a); // legge un valore intero nella variabile a scanf("%d", &b); // legge un valore intero nella variabile b res = a + b; printf("%d + %d = %d\n", a, b, res); return 0; )

Compila ed esegui questo programma. Dopo che il programma è stato avviato, attenderà che tu inserisca i dati. Io e te sappiamo quali dati devi inserire, perché. abbiamo scritto questo programma. Per gli altri utenti che non vedranno il codice del programma, sarebbe bello visualizzare un suggerimento sullo schermo quali dati inserire. Guarda come viene implementato nell'esempio seguente.

Questo programma sarà utile per coloro che controllano la propria salute. Questo programma calcola il metabolismo basale utilizzando la formula Mifflin-St.Geor in base ai dati inseriti (età, altezza e peso).

Listato 3.

#includere int main(void)( int age, height, weight; double bov_m, bov_f; printf("Vash vozrast?(god)\n"); scanf("%d", &age); // legge il valore intero nella variabile age printf("Vash rost?(cm)\n"); scanf("%d", &height); // legge il valore nella variabile di altezza printf("Vash ves?(kg)\n"); scanf("%d ", &weight); // legge il valore nella variabile weight bov_m = 10*peso + 6.25*altezza - 5*età + 5; bov_f = 10*peso + 6.25*altezza - 5*età - 161; printf("| BMR | \n"); printf("| maschio | femmina |\n"); printf("|%8.2f|%8.2f|\n",bov_m, bov_f); return 0; )

In realtà, la funzione scanf è una funzione di input del formato. È quasi più complicato di printf . Ma raccontare a un principiante le caratteristiche del suo lavoro è caricarlo invano. ulteriori informazioni. In questa fase, questa conoscenza ti sarà sufficiente e quando sarà necessario utilizzare qualcosa di più, potrai affrontarla da solo. O forse te lo dirò in qualche lezione.

La libreria standard C/C++ include una serie di funzioni per la lettura e la scrittura sulla console (tastiera e monitor). Queste funzioni leggono e scrivono dati come un semplice flusso di caratteri.

Il concetto di stream (stream), utilizzato nella programmazione, è strettamente correlato alla consueta comprensione quotidiana di questa parola. Il flusso in ingresso può essere confrontato con un tubo attraverso il quale l'acqua (informazioni) entra nella piscina (memoria del computer), il flusso in uscita - con un tubo attraverso il quale l'acqua lascia la piscina. Una caratteristica importante Questa pipe è che i dati possono spostarsi solo in una direzione alla volta. Anche se lo stesso tubo viene utilizzato per l'ingresso e l'uscita, non può accadere contemporaneamente: per cambiare la direzione del flusso, è necessario interromperlo, eseguire alcune azioni e solo allora dirigere il flusso nella direzione opposta. Un'altra caratteristica del flusso è che non si asciuga quasi mai. A volte si esaurisce, ma questo periodo non può essere lungo se il sistema funziona normalmente.

printf() funzione di output standard

La funzione printf() è una funzione di output standard. Con questa funzione è possibile visualizzare sullo schermo del monitor una stringa di caratteri, un numero, un valore variabile...

La funzione printf() ha un prototipo nel file stdio.h
int printf(char *stringa di controllo, ...);

In caso di successo, la funzione printf() restituisce il numero di caratteri stampati.

La stringa di controllo contiene due tipi di informazioni: caratteri che vengono visualizzati direttamente sullo schermo e identificatori di formato che determinano come restituire gli argomenti.

La funzione printf() è una funzione di output formattata. Ciò significa che nei parametri di funzione è necessario specificare il formato dei dati da emettere. Il formato dei dati è specificato dagli identificatori di formato. L'identificatore di formato inizia con una % seguita da un codice di formato.

Identificatori di formato:

Inoltre, i modificatori l e h possono essere applicati ai comandi di formattazione.

Nell'identificatore di formato, dopo il simbolo %, è possibile specificare la precisione (il numero di cifre dopo il punto decimale). La precisione è impostata come segue: %.n<код формата>. Dove n è il numero di cifre dopo la virgola decimale, e<код формата>- uno dei codici sopra.

Ad esempio, se abbiamo una variabile x=10.3563 di tipo float e vogliamo visualizzarne il valore con una precisione di 3 cifre decimali, allora dovremmo scrivere:

printf("Variabile x = %.3f",x);

Risultato:
Variabile x = 10.356

È inoltre possibile specificare la larghezza minima del margine da stampare. Se la stringa o il numero è maggiore della larghezza del campo specificata, la stringa o il numero viene stampato per intero.

Ad esempio, se scrivi:

printf("%5d",20);

allora il risultato sarà:
20

Si noti che il numero 20 non è stato stampato dall'inizio della riga. Se vuoi che le posizioni inutilizzate del campo vengano riempite con zeri, devi inserire il carattere 0 davanti alla larghezza del campo.

Per esempio:

printf("%05d",20);

Risultato:
00020

Oltre agli identificatori di formato dati in linea di controllo i caratteri di controllo possono essere:

Molto spesso utilizzerai il carattere \n. Con questo personaggio di controllo sarai in grado di saltare a una nuova riga. Guarda gli esempi di programmi e capirai tutto.

Esempi di programma.

/* Esempio 1 */
#includere

vuoto principale (vuoto)
{
int a,b,c; // Anno Domini variabili a,b,c
a=5;
b=6;
c=9;
printf("a=%d, b=%d, c=%d",a,b,c);
}

Il risultato del programma:
a=5, b=6, c=9

/* Esempio 2 */
#includere

vuoto principale (vuoto)
{
galleggiante x,y,z;

X=10,5;
y=130,67;
z=54;

Printf("Coordinate oggetto: x:%.2f, y:%.2f, z:%.2f", x, y, z);
}

Il risultato del programma:
Coordinate oggetto: x:10.50, y:130.67, z:54.00

/* Esempio 3 */
#includere

vuoto principale ()
{
intx;

X=5;
printf("x=%d", x*2);
}

Il risultato del programma:
x=10

/* Esempio 4 */
#includere

vuoto principale (vuoto)
{
printf("\"Testo tra virgolette\"");
printf("\nContenuto di ossigeno: 100%%");
}

Il risultato del programma:
"Testo tra virgolette"
Contenuto di ossigeno: 100%

/* Esempio 5 */
#includere

vuoto principale (vuoto)
{
int a;

A=11; // 11 in decimale è uguale a b in esadecimale
printf("a-dec=%d, a-hex=%X",a,a);
}

Il risultato del programma:
a-dec=11, a-hex=b

/* Esempio 6 */
#includere

vuoto principale (vuoto)
{
char ch1,ch2,ch3;

Ch1="A";
ch2="B";
ch3="C";

Printf("%c%c%c",ch1,ch2,ch3);
}

Il risultato del programma:
ABC

/* Esempio 7 */
#includere

vuoto principale (vuoto)
{
char *str="La mia stringa.";

Printf("Questo è %s",str);
}

Il risultato del programma:
Questa è la mia linea.

/* Esempio 8 */
#includere

vuoto principale (vuoto)
{
printf("Ciao!\n"); // Dopo la stampa, ci sarà una nuova riga - \n
printf("Mi chiamo Paolo."); // Verrà stampato su una nuova riga
}

Il risultato del programma:
Ciao!
Mi chiamo Pavel.

scanf() funzione di input standard

funzione scanf() - funzione di input formattato. Ti permette di inserire dati da dispositivo standard input (tastiera). Gli input possono essere numeri interi, numeri in virgola mobile, caratteri, stringhe e puntatori.

La funzione scanf() ha il seguente prototipo in stdio.h:
int scanf(carattere *stringa di controllo);

La funzione restituisce il numero di variabili a cui è stato assegnato un valore.

La stringa di controllo contiene tre tipi di caratteri: identificatori di formato, spazi e altri caratteri. Gli identificatori di formato iniziano con il carattere %.

Identificatori di formato:

Quando si inserisce una stringa usando la funzione scanf() (identificatore di formato %s), la stringa viene inserita fino al primo spazio!! quelli. se inserisci la stringa "Hello world!" usando la funzione scanf()

scanf("%s",str);

quindi dopo aver inserito la stringa risultante, che verrà archiviata nell'array str, sarà composta da una parola "Hello". LA FUNZIONE ENTRA IN STRINGA FINO AL PRIMO SPAZIO! Se vuoi inserire stringhe con spazi, usa la funzione

char *gets(char *buf);

Con la funzione gets(), puoi inserire stringhe complete. La funzione gets() legge i caratteri dalla tastiera finché non viene visualizzato un carattere nuova linea(\n). Il carattere di nuova riga viene visualizzato quando si preme tasto Invio. La funzione restituisce un puntatore a buf. buf - buffer (memoria) per la stringa di input.

Anche se gets() non rientra nell'ambito di questo articolo, scriviamo un programma di esempio che consente di inserire un'intera riga dalla tastiera e di visualizzarla sullo schermo.

#includere

vuoto principale (vuoto)
{
carbone di legna; // array (buffer) per la stringa di input

Ottiene (buffer); // inserisci una stringa e premi invio
printf("%s",buffer); // visualizza sullo schermo la stringa inserita
}

Altro nota importante! Per inserire i dati utilizzando la funzione scanf(), è necessario passare gli indirizzi delle variabili come parametri e non le variabili stesse. Per ottenere l'indirizzo di una variabile, fai precedere il nome della variabile con & (e commerciale). Il segno & significa prendere l'indirizzo.

Cosa significa indirizzo? Provo a spiegare. Nel programma abbiamo una variabile. Una variabile memorizza il suo valore nella memoria del computer. Quindi l'indirizzo che otteniamo con & è l'indirizzo nella memoria del computer in cui è memorizzato il valore della variabile.

Diamo un'occhiata a un programma di esempio che ci mostra come usare &

#includere

vuoto principale (vuoto)
{
intx;

Printf("Inserisci variabile x:");
scanf("%d",&x);
printf("Variabile x=%d",x);
}

Ora torniamo alla linea di controllo della funzione scanf(). Ancora:

int scanf(carattere *stringa di controllo);

Il carattere spazio nella riga di controllo indica di saltare uno o più spazi nel flusso di input. Oltre a uno spazio, è possibile accettare un carattere di tabulazione o di nuova riga. Un carattere non nullo indica di leggere e scartare quel carattere.

I separatori tra due numeri di input sono spazi, tabulazioni o caratteri di nuova riga. Il * dopo la % e prima del codice di formato (identificatore di formato) indica di leggere i dati del tipo specificato, ma non di assegnare quel valore.

Per esempio:

scanf("%d%*c%d",&i,&j);

digitando 50+20 imposterà i su 50, j su 20 e il + verrà letto e ignorato.

Il comando format può specificare la larghezza del campo più grande da leggere.

Per esempio:

scanf("%5s",str);

specifica di leggere i primi 5 caratteri dal flusso di input. Se inserisci 1234567890ABC, l'array str conterrà solo 12345, il resto dei caratteri verrà ignorato. Separatori: spazio, tabulazione e nuova riga - quando si inserisce un carattere, vengono trattati come tutti gli altri caratteri.

Se vengono rilevati altri caratteri nella stringa di controllo, sono destinati a determinare e ignorare il carattere corrispondente. Flusso di caratteri 10plus20 per operatore

scanf("%dplus%d",&x,&y);

assegnerà x a 10, y a 20 e salterà i caratteri più perché si trovano sulla linea di controllo.

Uno di caratteristiche potenti la funzione scanf() è la capacità di impostare il set di ricerca (scanset). Il set di ricerca definisce l'insieme di caratteri con cui verranno confrontati i caratteri letti da scanf(). La funzione scanf() legge i caratteri fintanto che si verificano nel set di ricerca. Una volta che il carattere immesso non viene trovato nel set di ricerca, la funzione scanf() passa all'identificatore di formato successivo. Il set di ricerca è definito da un elenco di caratteri racchiusi tra parentesi quadre. La parentesi aperta è preceduta da un segno %. Diamo un'occhiata a questo con un esempio.

#includere

vuoto principale (vuoto)
{
carattere str1, str2;
scanf("%%s", str1, str2);
printf("\n%s\n%s",str1,str2);
}
Inseriamo un set di caratteri:
12345abcdefg456

Sullo schermo il programma visualizzerà:
12345
abcdefg456

Quando si specifica un set di ricerca, è anche possibile utilizzare il trattino per specificare gli spazi, nonché la larghezza massima del campo di input.

scanf("%10", str1);

Puoi anche definire caratteri che non sono nel set di ricerca. Il primo di questi caratteri è preceduto da un segno ^. Il set di caratteri distingue tra lettere minuscole e maiuscole.

Lascia che ti ricordi che quando usi la funzione scanf(), devi passarle gli indirizzi delle variabili come parametri. Il codice sopra è stato scritto:

carta; // array per 80 caratteri
scanf("%s",str);

Si noti che str non è preceduto da &. Questo perché str è un array e il nome dell'array, str, è un puntatore al primo elemento dell'array. Pertanto, il segno & non viene inserito. Stiamo già passando l'indirizzo alla funzione scanf(). Bene, in poche parole, str è l'indirizzo nella memoria del computer in cui verrà archiviato il valore del primo elemento dell'array.

Esempi di programma.

Esempio 1
Questo programma visualizza la query "Quanti anni hai?:" e attende l'input. Se ad esempio si inserisce il numero 20, il programma visualizzerà la stringa "Hai 20 anni.". Quando abbiamo chiamato la funzione scanf(), abbiamo prefissato la variabile age con un &, perché la funzione scanf() necessita degli indirizzi delle variabili. La funzione scanf() scriverà il valore inserito in base a indirizzo specificato. Nel nostro caso, il valore inserito 20 verrà scritto all'indirizzo della variabile età.

/* Esempio 1 */

#includere

vuoto principale (vuoto)
{
età intera;

Printf("\nQuanti anni hai?:");
scanf("%d",&age);
printf("Hai %d anni.", età);
}

Esempio 2
Programma calcolatrice. Questa calcolatrice può solo aggiungere numeri. Se inserisci 100+34, il programma restituirà il risultato: 100+34=134.

/* Esempio 2 */

#includere

vuoto principale (vuoto)
{
int x, y;

Printf("\nCalcolatrice:");
scanf("%d+%d", &x, &y);
printf("\n%d+%d=%d", x, y, x+y);
}

Esempio 3
Questo esempio mostra come impostare la larghezza del campo di lettura. Nel nostro esempio, la larghezza del campo è di cinque caratteri. Se inserisci una riga con grande quantità personaggi, tutti i personaggi dopo il 5 verranno scartati. Prestare attenzione alla chiamata alla funzione scanf(). Il segno & non precede il nome del nome dell'array perché il nome del nome dell'array è l'indirizzo del primo elemento dell'array.

/* Esempio 3 */

#includere

vuoto principale (vuoto)
{
nome del personaggio;

Printf("\nInserisci il tuo nome utente (massimo 5 caratteri):");
scanf("%5s", nome);
printf("\nHai inserito %s", nome);
}

Esempio 4
L'ultimo esempio in questo articolo mostra come utilizzare il set di ricerca. Dopo aver avviato il programma, inserire un numero da 2 a 5.

/* Esempio 4 */

#includere

vuoto principale (vuoto)
{
carbale;

Printf("Il tuo punteggio è 2,3,4,5:");
scanf("%", &bal);
printf("\nPunteggio %c", bal);
}

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.

Fai attenzione: qualsiasi altro carattere nella stringa di controllo, inclusi spazi, tabulazioni e nuove righe, viene utilizzato per specificare 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. La prima parentesi quadra è preceduta da un 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.)

]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 " ", carattere di tabulazione \t, carattere di nuova riga "\n". Per la funzione scanf, il carattere dello spazio vuoto è definito per leggere, ma non ricordare, tutti i successivi caratteri dello spazio vuoto immessi, fino al primo carattere diverso da uno spazio vuoto. 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 puntatore float 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 nella restrizione parentesi quadre molti personaggi. Se il primo carattere di questo set è il cursore (^), il risultato viene conservato: 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; oppure il carattere seguente è in conflitto con il suo carattere corrispondente nella stringa di controllo del 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, o 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.