RaspberryItaly Community Italiana
Ebbene oggi vedremo i primi tipi del linguaggio C: gli interi ed i floating point. Dopo averne visto le caratteristiche, proveremo ad usarli in semplici esempi, imparando a stamparli.
Prima di tutto vedremo come inserire un commento nel codice sorgente, possibilità davvero utile
Sommario
- I commenti nel codice sorgente
- I tipi interi
- La stampa degli interi
- I limiti per gli interi
- I tipi floating
- La stampa dei floating
- Riassunto
- Esercizi
1 I commenti nel codice
E’ proprio vero, anche il linguaggio C ammette i commenti.
La forma del commento originale è quello riportato di seguito
/* commento */
/*************
** commento **
*************/
/*
** commento
*/
In sostanza si tratta di aprire il commento con i due caratteri /* e chiuderlo con */
In seguito a questo fu aggiunto il commento introdotto dal C++ ossia:
// commento
Si tratta di un commento scritto su di una riga sola che inizia con i caratteri //
Prima di proseguire, come consiglio, ricordiamo che è sempre bene commentare i codici sorgenti.
Questo può risultare utile per gli altri che potrebbero voler leggere il nostro programma, ma anche per noi stessi.
Se volessimo modificare o riadattare un nostro lavoro tra una settimana, un mese o anni, non avete idea delle difficoltà che incontrereste: provare per credere!
2 I tipi interi
Il linguaggio C ammette 4 tipi di interi che sono:
- char: 8bit – 1 byte
- short: 16bit – 2byte
- int: 32bit – 4byte
- long long int 64bit – 8byte
questi identificatori così usati si intendono con segno.
Alternativamente, esiste una versione senza segno (quindi solo positivi) con la medesima estensione in termine di bit e byte:
- unsigned char
- unsigned short
- unsigned int
- unsigned long long int
Quindi, in base al numero che vogliamo rappresentare, possiamo scegliere un tipo piuttosto che un altro.
Caso particolare poi sono i char in quanto sono in stretta relazione con la tabella dei codici ASCII.
I numeri infatti potrebbero essere stampati come caratteri. Vedremo questo aspetto nel paragrafo seguente
3 La stampa degli interi
Utilizzeremo la funzione printf, che abbiamo visto la lezione scorsa, la cui sintassi potrebbe essere espressa come
printf("formato",variabile1, variabile2,...)
dove formato può essere una stringa o una sequenza di caratteri speciali che indicano come stampare la variabile. Nel caso delle grandezze intere con segno, eccetto il long long int, per tutti gli altri tre si può usare il formato generale %d, mentre per il caso mancante bisogna usare %lld. Nel caso di variabile senza segno, il generico formato per i primi tre tipi è %u e per gli ultimi %llu
Come caso particolare, qualora si volesse stampare il carattere corrispondente (sempre se visualizzabile) di un char, si usa il formato %c.
Proviamo adesso a raccogliere tutte queste informazioni ed applichiamole nel file esempio2_1.c
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 |
/****************************************** esempio2_1.c In questo codice proveremo a stampare tutti i tipi di interi che abbiamo visto arkkimede marzo 2021 *******************************************/ #include <stdio.h> int main() { /* dichiarazione e valorizzazione delle variabili Si noti come sia possibile dichiarare e valorizzare una variabile nello stesso tempo */ char c = 65; short s = -126; int i = 12870; long long int q = -123456789; unsigned char uc = 67; unsigned short us = 240; unsigned int ui = 45670; unsigned long long int uq = 987564321; /* Stampa di un carattere come numero */ printf("carattere formato numerico: %d \n",c); /* Stampa del corrispondente valore del codice ascii */ printf("carattere (codie ascii): %c \n",c); /* Stampa di uno short */ printf("short: %d \n",s); /* Stampa di uno intero */ printf("intero: %d \n",i); /* Stampa di un long long int */ printf("long long int: %lld \n",q); /* Stampa di un carattere senza segno come numero */ printf("carattere senza segno formato numerico: %u \n",uc); /* Stampa del corrispondente valore del codice ascii */ printf("carattere senza segno (codie ascii): %c \n",uc); /* Stampa di uno short senza segno */ printf("shorti senza segno: %u \n",us); /* Stampa di uno intero senza segno */ printf("intero senza segno: %u \n",ui); /* Stampa di un long long int senza segno */ printf("long long int senza segno: %llu \n",uq); return 0; } |
In questo esempio è stata utilizzata la dichiarazione e valorizzazione delle variabili nella stessa istruzione.
E’ bene precisare, comunque, che per ogni tipo sono codificati altri formati e volendo si possono usare anche quelli. A titolo di esempio si veda qui.
4 I limiti per gli interi
Negli header è possibile anche riportare delle costanti (per convenzione scritte tutte in maiuscolo).
In particolare, l’header limit.h riporta i dati relativi agli interi. Nell’esempio2_2.c proveremo a stampare questi limiti
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
/********************************** esempio2_2.c Codice che stampa i limiti per tutti i tipi interi, con segno e senza segno arkkimede marzo 2021 **********************************/ #include <limits.h> #include <stdio.h> int main() { printf("Numero di bit presenti nella variabile char: %d\n",CHAR_BIT); printf("Valore minimo per una variabile char (o signed char): %d\n",SCHAR_MIN); printf("Valore massimo per una variabile char (o signed char): %d\n",SCHAR_MAX); printf("Valore massimo per una variabile unsigned char: %d\n",UCHAR_MAX); printf("Valore minimo per una variabile short: %d\n",SHRT_MIN); printf("Valore massimo per una variabile short: %d\n",SHRT_MAX); printf("Valore massimo per una variabile unsigned short: %d\n",USHRT_MAX); printf("Valore minino per un int: %d \n",INT_MIN); printf("Valore massimo per un int: %d \n",INT_MAX); printf("Valore massimo per un unsigned int: %u \n",UINT_MAX); printf("Valore minimo per un long long int: %lld \n",LLONG_MIN); printf("Valore massimo per un long long int: %lld \n",LLONG_MAX); printf("Valore massimo per un unsigned long long int: %llu \n",ULLONG_MAX); return 0; } |
Mandando in esecuzione il codice, potrete verificare che tra il massimo del tipo con segno ed il massimo del tipo senza segno vi è un fattore 2.
Infatti il tipo con segno deve utilizzare un bit per indicare il segno mentre il tipo senza segno può utilizzare tutti i bit per costruire la cifra.
Essendo una rappresentazione binario, il 2 in più moltiplicherà la cifra risultante ancora per 2.
5 I tipi floating
Comunemente sono noti come numeri con la virgola.
Il C ne prevede di due tipi
- float 32bit – 4byte
- double 64bit – 8byte
Come per gli interi, sulla base della grandezza che vogliamo rappresentare, ma principalmente sulla precisione che ci necessita, possiamo usare un tipo piuttosto che l’altro.
6 La stampa dei floating
Come per gli interi la stampa dei floating point necessitano un formato.
Per i float %f per i double %lf. Questi numeri possono anche essere stampati in formato esponenziale ed allora abbiamo %e per i primi e %le per i secondi.
Ultima notazione prima di vedere un esempio, è sempre possibile definire quante cifre far apparire nella stampa (assunto che vale anche per gli interi). Per quanto riguarda i float abbiamo una notazione del tipo n.m%lf dove la prima cifra indica quanti caratteri devono essere stampati (contando eventuale segno e punto decimale), la seconda cifra il numero di cifre decimali.
In esempio2_3.c vediamo come sono applicate queste notazioni
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
/******************************* esempio2_3.c Codice di esempio per stampare float e double. Al fondo è riportato l'output del codice arkkimede marzo 2021 *******************************/ #include <stdio.h> int main() { float a=12.14567; double b=1456.234; printf("float con virgola |%5.2f|\n",a); printf("float come esponenziale |%10.3e|\n",a); printf("double con virgola |%8.3lf|\n",b); printf("double come esponenziale |%15.4le|\n",b); return 0; } /* Output: float con virgola |12.15| float come esponenziale | 1.215e+01| double con virgola |1456.234| double come esponenziale | 1.4562e+03| */ |
7 Riassunto
- I commenti possono farsi: /* commento */ oppure //commento
- 4 sono i tipi interi, char, short, int e long long int, hanno estensioni (in bit) diverse e possono rappresentare tutte le grandezze intere. Con la parola chiave unsigned, sono solo positivi
- Grazie a limits.h è possibile conoscere i limiti degli interi con e senza segno
- Per stampare gli interi con la printf, il formato generale per char, short e int è %d, mentre per long long int è %lld
- I tipi floating point sono 2: float e double
- Per stampare i floating point con la printf, i formati sono, rispettivamente, %f e %lf nella notazione con la virgola, %e e %le nella notazione esponenziale
8 Esercizi
- Provare a scrivere un programma che stampi i vari tipi di interi.
- Provare a stampare il numero 10 usando come formato prima %6d e poi %06d ed osservare cosa succede all’uscita. (Per essere sicuri dell’effetto del formato, si possono sempre mettere due barre verticali attorno al formato |%6d| e |%06d| come nell’esempio proposto
- Provare a valorizzare una variabile intera con un numero fuori dai suoi limiti e vedere cosa succede
- Stampare floating point famigliarizzando con i vari formati e le varie estensioni
Ed anche la seconda lezione è finita.
Arrivederci alla prossima
Qui il forum di supporto al corso.
Se vuoi restare aggiornato, seguici anche sui nostri social: Facebook, Twitter, Youtube
Se vuoi anche trovare prodotti e accessori Raspberry Pi in offerta, seguici anche su Telegram !!
