{"id":113,"date":"2010-08-27T13:18:00","date_gmt":"2010-08-27T13:18:00","guid":{"rendered":"http:\/\/e-ware.org\/blog\/?p=113"},"modified":"2010-08-27T13:18:00","modified_gmt":"2010-08-27T13:18:00","slug":"guida-al-c-parte-2-il-resto-del-pinguino","status":"publish","type":"post","link":"http:\/\/e-ware.org\/blog\/guida-al-c-parte-2-il-resto-del-pinguino\/","title":{"rendered":"Guida al C: parte 2 (Il resto del Pinguino)"},"content":{"rendered":"
<\/div>\n
\"\"<\/a><\/p>\n
Tratto da “Il resto del Pinguino”<\/a><\/span><\/div>\n

<\/span><\/div>\n

<\/div>\n
Le variabili e le costanti in C<\/span><\/div>\n

<\/span><\/div>\n
Per <\/span>variabile<\/span><\/b> si intende una porzione di memoria atta a contenere un determinato dato che potr\u00e0 poi essere modificato nel corso dell’uso del programma. Essa pu\u00f2 essere inizializzata all’atto della sua dichiarazione con un valore di default o pu\u00f2 essere dichiarata senza alcun valore. In tal caso il linguaggio non garantisce un valore<\/span><\/div>\n
iniziale utile. Ad esempio una variabile pu\u00f2 essere dichiarata ed inizializzata in due modi diversi. Per doppio passaggio:<\/span><\/div>\n

<\/span><\/div>\n
\/\/ dichiaro<\/span><\/i><\/div>\n
int x;<\/span><\/i><\/div>\n
\/\/ inizializzo<\/span><\/i><\/div>\n
x = 14;<\/span><\/i><\/div>\n

<\/span><\/div>\n
o direttamente:<\/span><\/div>\n

<\/span><\/div>\n
\/\/ dichiaro ed inizializzo<\/span><\/i><\/div>\n
int x = 14;<\/span><\/i><\/div>\n

<\/span><\/div>\n
Una <\/span>costante<\/span><\/b>, invece, \u00e8 una porzione di memoria che viene dichiarata per contenere un determinato tipo di dato e ne conserva il valore per tutta la durata dell’uso del programma senza mai poterne modificare il valore. Ogni variabile o costante nel C deve essere identificata da un nome al quale si far\u00e0 poi riferimento nel corso dello svolgimento del programma per leggere o scriverci dati. Il nome delle variabili in C \u00e8 arbitrario e pu\u00f2<\/span><\/div>\n
avere lunghezza variabile per\u00f2 il compilatore si interesser\u00e0 solo delle <\/span>prime 8 lettere<\/span><\/b> che lo compongono. Quindi anche se a prima vista un dato di nome “variabile1” pare diverso da “variabile2”, il compilatore restituir\u00e0 errore poich\u00e8 vedr\u00e0 due variabili con lo stesso nome ovvero “variabil”. Il C \u00e8 un linguaggio che basa la sua struttura sui dati. Dati diversi, infatti, equivalgono a cose diverse. Questo tipo di gestione permette di avere un buon uso della memoria perch\u00e9 ad ogni tipo di dato \u00e8 dedicata la giusta quantit\u00e0 di memoria e in pi\u00f9 d\u00e0 la possibilit\u00e0 di usare o creare strutture ad hoc per le diverse esigenze di sviluppo. Il C gode delle presenza di 6 tipi di dati base:<\/span><\/div>\n

<\/span><\/div>\n
char<\/span><\/b><\/i><\/div>\n
int<\/span><\/b><\/i><\/div>\n
long<\/span><\/b><\/i><\/div>\n
short<\/span><\/b><\/i><\/div>\n
float<\/span><\/b><\/i><\/div>\n
double<\/span><\/b><\/i><\/div>\n

<\/span><\/div>\n
Il <\/span>char<\/span><\/b> \u00e8 il dato adibito alla gestione dei caratteri. Ogni volta che viene dichiarata una variabile di tipo char essa occupa una quantit\u00e0 di memoria pari a <\/span>8 bit<\/span><\/b> (1 byte). Il char, nonostante sia effettivamente un tipo di dato numerico, permette la gestione del suo valore come una normale “lettera”. Un array (vettore) di char permette la virtualizzazione di una stringa mentre, in altri linguaggi, esiste ormai un tipo di dato string dedicato. Un esempio di dichiarazione di un dato char inizializzato \u00e8:<\/span><\/div>\n

<\/span><\/div>\n
char carattare = ‘ a’ ;<\/span><\/i><\/div>\n

<\/span><\/div>\n
E’ importante notare come definire il carattere ‘8’, ad esempio, \u00e8 totalmente diverso dalla definizione di un valore intero 8. Un char che contiene il carattere ‘8’ in realt\u00e0 avr\u00e0 al suo intero il valore numerico che, in base alla codifica in uso, equivale a quel determinato carattere mentre una variabile numerica che contiene 8 avr\u00e0 proprio quel valore preciso in memoria. <\/span><\/div>\n

<\/span><\/div>\n
L’ <\/span>int<\/span><\/b> \u00e8 il tipo adibito a contenere dati numerici di numeri interi o meglio definiti come numeri naturali. Tali numeri, pertanto, devono contenere numeri senza virgole, frazioni, parti immaginarie, etc… un dato di tipo int, all’atto della sua dichiarazione, occupa <\/span>16 bit <\/span><\/b>(2 byte). I valori che un int pu\u00f2 assumere vanno da -32.768 a +32.767 se si usa il segno (valori positivi o negativi) o va da 0 a 65535 per soli numeri interi. Un esempio di dichiarazione di un dato int inizializzato \u00e8:<\/span><\/div>\n

<\/span><\/div>\n
int numIntero = 14;<\/span><\/i><\/div>\n

<\/span><\/div>\n
Long<\/span><\/b> pu\u00f2 essere visto come un particolare int creato appositamente per ovviare al problema di uso di numeri pi\u00f9 grandi di quelli che l’ int offre. Esso occupa una quantit\u00e0 di memoria pari a <\/span>32 bit<\/span><\/b> (4 byte) ed offre la possibilit\u00e0 di usare valori che vanno da -2.147.483.648 a +2.147.483.647 per numeri con segno o da 0 a 4.294.967.295 per numeri privi del segno. Un esempio di dichiarazione di un dato long inizializzato \u00e8:<\/span><\/div>\n

<\/span><\/div>\n
long numIntLong = 1000000000;<\/span><\/i><\/div>\n

<\/span><\/div>\n
Lo <\/span>short<\/span><\/b> \u00e8 un dato molto simile all’int ma che trova limitazioni pi\u00f9 restrittive per quanto riguarda il suo valore massimo o minimo. Esso infatti occupa <\/span>8 bit<\/span><\/b> (1 byte) e pu\u00f2 perci\u00f2 coprire un range che va da -127 a +128 pe numeri con segno mentre va da 0 a 256 per numeri senza segno.<\/span><\/div>\n

<\/span><\/div>\n
I <\/span>float<\/span><\/b> e i <\/span>double<\/span><\/b> sono particolari tipi di dati che danno la posibilit\u00e0 di rappresentare i numeri in virgola mobile, ovvero i numeri reali. La differenza tra i due tipi di dati sta nella quantit\u00e0 di memoria utilizzata e pertanto nell’accuratezza con cui i numeri possono essere rappresentati. Un float, infatti, richiede una quantit\u00e0 di memoria pari a <\/span>32 bit<\/span><\/b> (4 byte) mentre un double richiede <\/span>64 bit<\/span><\/b> (8 byte). Un esempio di dichiarazione di un dato float e di un double inizializzato \u00e8:<\/span><\/div>\n

<\/span><\/div>\n
double dblVirgola = 5.023;<\/span><\/i><\/div>\n
float fltVirgola = 7.8;<\/span><\/i><\/div>\n

<\/span><\/div>\n
SIGNED ed UNSIGNED<\/span><\/div>\n

<\/span><\/div>\n
Come si \u00e8 visto, ogni dato ha la possibilit\u00e0 di considerare l’insieme dei suoi valori limitato diversamente in base all’uso che se ne vuole fare. Ad esempio due dati, entrambi int, potranno assumere valori massimi diversi se uno \u00e8 sempre positivo mentre l’altro assume sia valori positivi che negativi. E’ importante avere in mente tale concetto per poter avere a disposizione sempre il miglior tipo di dato per le nostre esigenze. Di default i dati in C vengon visti come signed e perci\u00f2 \u00e8 possibile usare il segno per definire il valore in maniera positiva o negativa. Qualora ci fosse bisogno di definire esplicitamente che un numero non necessita di una rappresentazione negativa allora si pu\u00f2 dichiarare la viariabile in questo modo:<\/span><\/div>\n

<\/span><\/div>\n
unsigned int Numero = 15;<\/span><\/i><\/div>\n

<\/span><\/div>\n
altrimenti \u00e8 possibile usare la sintassi:<\/span><\/div>\n

<\/span><\/div>\n
signed int Numero = – 15;<\/span><\/i><\/div>\n

<\/span><\/div>\n
che \u00e8 equivalente a<\/span><\/div>\n

<\/span><\/div>\n
int Numero = – 15;<\/span><\/i><\/div>\n

<\/span><\/div>\n
COSTANTI<\/span><\/div>\n

<\/span><\/div>\n
Il discorso trattato fin ora era studiato per l’uso delle variabili; tuttavia, tutte le regole di cui sopra valgono anche per quanto riguarda il trattamente di dati costanti. Bisogna comunque ricordare che essi mantengono il valore iniziale e perci\u00f2 quanto detto vale solo all’atto della dichiarazione e mai durante lo svolgimento del programma. Un esempio di dichiarazione di una costante pu\u00f2 essere:<\/span><\/div>\n

<\/span><\/div>\n
const float PIGRECO = 3. 14;<\/span><\/i><\/div>\n

<\/span><\/div>\n
Da notare la presenza della parola chiave const che definisce il dato come costante.<\/span><\/div>\n

<\/span><\/div>\n
CASTING E CONCLUSIONE<\/span><\/div>\n

<\/span><\/div>\n
Visto il tipo di gestione dei dati in C, esso viene definito come linguaggio a tipizzazione statica, ovvero dove i tipi di dati vengono definiti all’inizio e mantenuti pressoch\u00e9<\/span><\/div>\n
costanti per la durata del software. Tuttavia esiste una pratica definita casting mediante la quale \u00e8 possibile cambiare il tipo di un dato per poterlo adattare ad una certa circostanza. Il casting si avvale della sintassi del tipo:<\/span><\/div>\n

<\/span><\/div>\n
variabile1 = ( tipo) variabile2<\/span><\/i><\/div>\n

<\/span><\/div>\n
Ad esempio per ottenere un int da un valore float \u00e8 possibile seguire il seguente codice di esempio:<\/span><\/div>\n

<\/span><\/div>\n
float fltNumero = 2. 36;<\/span><\/i><\/div>\n
int intNumero;<\/span><\/i><\/div>\n

<\/span><\/div>\n
intNumero = (int) fltNumero;<\/span><\/i><\/div>\n

<\/span><\/div>\n
In questo modo intNumero assumer\u00e0 valore 2, ovvero la parte intera del numero float. <\/span><\/div>\n

<\/span><\/div>\n
Conoscere i dati in C significa essere a conoscenza delle fondamenta di un linguaggio ed \u00e8 perci\u00f2 importante studiare bene l’argomento prima di addentrarsi in argomenti pi\u00f9 avanzati.<\/span><\/div>\n
<\/div>\n","protected":false},"excerpt":{"rendered":"

Tratto da “Il resto del Pinguino” Le variabili e le costanti in C Per variabile si intende una porzione di memoria atta a contenere un determinato dato che potr\u00e0 poi essere modificato nel corso dell’uso del programma. Essa pu\u00f2 essere inizializzata all’atto della sua dichiarazione con un valore di default o pu\u00f2 essere dichiarata senza […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[54,52,2,4,44],"tags":[],"class_list":["post-113","post","type-post","status-publish","format-standard","hentry","category-c","category-didattica","category-gnulinux","category-opencode","category-windows"],"views":1116,"_links":{"self":[{"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/posts\/113","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/comments?post=113"}],"version-history":[{"count":0,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/posts\/113\/revisions"}],"wp:attachment":[{"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/media?parent=113"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/categories?post=113"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/e-ware.org\/blog\/wp-json\/wp\/v2\/tags?post=113"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}