{"id":6829,"date":"2011-05-04T18:24:12","date_gmt":"2011-05-04T16:24:12","guid":{"rendered":"http:\/\/www.devapp.it\/wordpress\/?p=6829"},"modified":"2011-10-05T12:24:37","modified_gmt":"2011-10-05T10:24:37","slug":"12-i-puntatori-parte-1","status":"publish","type":"post","link":"https:\/\/www.devapp.it\/wordpress\/12-i-puntatori-parte-1\/","title":{"rendered":"12. I Puntatori – parte 1"},"content":{"rendered":"

\"corso-completo-c-i-puntatori-parte-1-00\"<\/a> Ed eccoci arrivati all’argomento che per tanti utenti rappresenta la “bestia nera” della programmazione in C, i puntatori. Purtroppo devo darvi una brutta notizia, tutta la programmazione moderna si basa in maniera pi\u00f9 o meno velata sull’uso dei puntatori, quindi non fatevi venire in mente di saltare questa lezione e mettiamoci subito al lavoro.<\/p>\n

Cos’\u00e8 un puntatore?<\/h4>\n

Un puntatore non \u00e8 nient’altro che un tipo di variabile cos\u00ec come lo sono int, long, char etc, il suo scopo, per\u00f2, non \u00e8 quello di memorizzare l’informazione in s\u00e8, come accade per le classiche variabili, ma quello di memorizzare l’indirizzo di memoria dove di fatto l’informazione \u00e8 memorizzata.<\/p>\n

Nota: <\/strong>Per chi non lo sapesse la memoria dei nostri computer \u00e8 organizzata in blocchi, ciascun blocco ha un proprio indirizzo (che non \u00e8 altro che un numero, spesso espresso in esadecimale come ad esempio 0x345F2A).<\/p>\n


\n\"corso-completo-c-i-puntatori-parte-1-01\"<\/a>
\n<\/center><\/p>\n

Va precisato che anche il puntatore, in quanto variabile, \u00e8 archiviato in memoria, quindi ha un suo proprio indirizzo, ma questo non ci deve confondere le idee.<\/p>\n

Nell’immagine vediamo 4 variabili, l’ultima memorizzata all’indirizzo di memoria 0x803FA4 \u00e8 una variabile di tipo puntatore ed il suo contenuto \u00e8 0x803FA2, quando dal programma accederemo a questa variabile (vedremo a breve come) verremo “dirottati” all’allocazione di memoria 0x803FA2 che ha come contenuto il numero 42.<\/p>\n

Utilizzare una variabile che contenga l’indirizzo dove recuperare il dato \u00e8 utile per realizzare quello che viene chiamato indirizzamento indiretto, ovvero piuttosto che utilizzare direttamente la variabile x utilizzo la variabile presente all’indirizzo di memoria puntato da x.<\/p>\n

Anche se pu\u00f2 sembrare piuttosto esoterico, l’indirizzamento indiretto \u00e8 indispensabile per il funzionamento interno della CPU (link<\/a>) mentre i linguaggi di pi\u00f9 alto livello lo utilizzano per fornire maggiore flessibilit\u00e0 ai programmi e per velocizzare le operazioni con variabili molto grandi in memoria.<\/p>\n

Facciamo un piccolo esempio, supponiamo di avere una variabile che occupi veramente molto spazio, e che questa variabile debba essere usata in due punti molto diversi del nostro programma. Piuttosto che effettuare una copia del dato, che comporterebbe uno spreco di tempo e memoria, possiamo creare un puntatore all’allocazione e utilizzare il puntatore all’interno del nostro codice cos\u00ec che quando ci servir\u00e0 una copia del dato baster\u00e0 effettuare una copia del solo puntatore, risparmiando un mucchio di tempo.<\/p>\n

Suppongo che nessuno si stia ponendo in questo momento una domanda cruciale, cio\u00e8: “Se il puntatore contiene solo l’informazione sull’indirizzo dove reperire il dato, dov’\u00e8 l’informazione sul tipo<\/strong> di dato?” ovvero “Come fa il nostro programma a sapere quanti byte leggere a partire dall’indirizzo di memoria puntato dal puntatore? Per un char dovrebbe leggere solo un byte, per un int 4 byte etc etc..” Bene, ottima domanda! Proprio per questo tutti i puntatori hanno un tipo, dichiareremo infatti un puntatore ad intero, oppure un puntatore a char e cos\u00ec via, in questo modo il nostro programma sapr\u00e0 quanti byte leggere.<\/p>\n

Una piccola eccezione \u00e8 data dal tipo “puntatore a void”, il termine “void” l’abbiamo gi\u00e0 incontrato quando abbiamo parlato delle funzioni, dicendo che una funzione che non restituisce alcun valore si dichiara come<\/p>\n

\r\nvoid nomefunzione {\r\n\r\n        \/\/codice della funzione.\r\n\r\n}\r\n<\/pre>\n
In questo caso il termine “void” indica che si tratta di un puntatore generico, che non ha specificato nessun tipo di dato, quindi punta in modo generico ad un intero blocco della memoria. Per utilizzarlo \u00e8 sempre possibile utilizzare l’operazione di cast (lezione 7<\/a>).<\/p>\n
Dichiarazione di un puntatore<\/h4>\n
Per dichiarare una variabile di tipo puntatore si usa una sintassi molto simile alla dichiarazione di una variabile normale, l’unica differenza \u00e8 che bisogna inserire un ” * ” prima del nome della variabile. Per esempio per dichiarare due variabili di tipo rispettivamente puntatore ad intero e puntatore a carattere la sintassi da utilizzare \u00e8 la seguente<\/p>\n
\r\nint *a;\r\nchar *b;\r\n<\/pre>\n
Una piccola nota sul carattere ” * “: non \u00e8 necessario scriverlo attaccato al nome della variabile, questa \u00e8 la convenzione che utilizzo io, ma in altri casi potreste trovare qualcosa come<\/p>\n
\r\nint* a;\r\nchar* b;\r\n<\/pre>\n
La questione \u00e8 puramente simbolica, ma anche qui ci sono parecchie scuole di pensiero, se avete voglia potete leggere il parere di B. Stroustrup, l’inventore del C++ (link<\/a>). L’ unica cosa certa \u00e8 che se vi capita di parlare con un programmatore non dovete dire “int asterisco a” ma “int star a” se volete essere sicuri di essere capiti.<\/p>\n
L’operatore (perch\u00e9 si tratta di un operatore, non di un orpello grafico) ” * ” si chiama operatore di deferenziazione e quando \u00e8 anteposto al nome di una variabile fa si che al suo posto venga utilizzato il valore dell’allocazione di memoria all’indirizzo contenuto nella variabile.<\/p>\n
Vediamo se tutto \u00e8 chiaro con una domanda difficile.<\/p>\n
Supponiamo di aver scritto questo codice, in cui dichiariamo una variabile di tipo puntatore ad intero e poi assegnamo tramite l’operatore di deferenziazione il valore 42.<\/p>\n
\r\n#include \r\n\r\nint main(int argc, char **argv) {\r\n\r\nint i,j;  \/\/variabili dichiarate ma non inizializzate. serviranno dopo.\r\n\r\nint *a;\r\n\r\n        *a = 42;\r\n\r\n        printf(\"Il puntatore punta ad una variabile che vale %d \", *a);\r\n\r\n}\r\n<\/pre>\n
Tutto sembra corretto, anche se compiliamo non ci sono errori particolari, eppure quando eseguiamo il programma appare un drammatico “segmentation fault”, come mai?<\/p>\n
Esaminiamo il codice, in particolare la riga:<\/p>\n
\r\n*a = 42;\r\n<\/pre>\n
Questa istruzione dovrebbe assegnare 42 alla variabile contenuta all’indirizzo di memoria contenuto nella variabile a, ma purtroppo la variabile a non \u00e8 stata inizializzata, quindi il suo valore, di solito \u00e8 zero oppure un valore non prevedibile, quindi quello che accade \u00e8 che il programma tenta di scrivere “42” in zone di memoria che non gli appartengono, quindi il sistema operativo per sicurezza lo blocca e genera l’errore “segmentation fault” facendo crashare il programma.<\/p>\n

\n\"corso-completo-c-i-puntatori-parte-1-02\"<\/a>
\n<\/center><\/p>\n
Quindi abbiamo scoperto che quando si usano i puntatori in realt\u00e0 le variabili da inizializzare sono due e non pi\u00f9 una sola, dobbiamo inizializzare il contenuto della variabile puntatore e inizializzare il contenuto della variabile puntata. Ma come si inizializza una variabile di tipo puntatore? Ci sono due metodi: il primo, che vedremo in una prossima lezione, \u00e8 quello di chiedere direttamente al sistema operativo un indirizzo di memoria libero da poter utilizzare, mentre il secondo consiste nell’assegnare ad un puntatore l’indirizzo di una variabile gi\u00e0 dichiarata. Ad esempio potremmo assegnare al puntatore “a” il valore 0x803FA3 che \u00e8 l’indirizzo dove \u00e8 memorizzata la variabile j.<\/p>\n
In questo modo con queste due inizializzazioni:<\/p>\n
\r\na = 0x803FA3;\r\n\r\n*a = 42;\r\n<\/pre>\n
non si genererebbe errore, perch\u00e9 0x803FA3 \u00e8 un indirizzo appartenente al nostro programma ed il sistema operativo non ci impedisce di accedervi.<\/p>\n
Attenzione:<\/strong> Nella riga a = 0x803FA3; non ho dimenticato l’asterisco e non \u00e8 un refuso di stampa, in questo caso vogliamo modificare il valore contenuto all’interno del puntatore, e non della variabile puntata dal puntatore, quindi il simbolo ” * ” non va messo.<\/p>\n
Ma come facciamo a conoscere l’indirizzo di memoria che il sistema operativo ha assegnato alle nostre variabili? 0x803FA3 \u00e8 solo un esempio inventato e non c’\u00e8 modo di sapere durante la scrittura di un codice qual’\u00e8 l’indirizzo che verr\u00e0 assegnato alle nostre variabili durante l’esecuzione del programma. Quindi come fare? Possiamo utilizzare un operatore che \u00e8 il duale dell’operatore di deferenziazione ed \u00e8 l’operatore ” & “.<\/p>\n
Anteposto al nome della variabile fa si che al suo posto venga utilizzato l’indirizzo della variabile.<\/p>\n
Quindi potremmo riscrivere il codice precedente in questo modo:<\/p>\n
\r\n#include \r\n\r\nint main(int argc, char **argv) {\r\n\r\nint i,j;  \/\/variabili dichiarate ma non inizializzate. serviranno dopo.\r\n\r\nint *a;\r\n\r\n        a = &j; \/\/assegno al puntatore a l'indirizzo della variabile j\r\n\r\n*a = 42; \/\/assegno all'indirizzo puntato da a il valore 42\r\n\r\n        printf(\"Il puntatore punta ad una variabile che vale %d \", *a);\r\n\r\n}\r\n<\/pre>\n
Quello che abbiamo fatto in questo esempio \u00e8 quello di far puntare il puntatore a<\/em> all’indirizzo dov’\u00e8 memorizzata la variabile j<\/em>, quindi possiamo modificare il valore di j<\/em> sia modificando j<\/em> stessa sia modificando *a<\/em>.<\/p>\n
Vediamo in questo esempio qualche esempio di utilizzo dell’operatore *<\/em> ed &<\/em>:<\/p>\n
\r\n#include \r\n\r\nint main(int argc, char **argv) {\r\n\r\n int valore_a;\r\n\r\n int *ptr1;\r\n\r\n ptr1 = &valore_a;\r\n\r\n *ptr1        = 42;\r\n\r\n printf(\"valore_a vale: %d \\n\", valore_a);\r\n\r\n printf(\"*ptr1 vale: %d\\n \", *ptr1);\r\n\r\n\/\/praticamente *ptr1 e valore_a sono sinonimi.\r\n\r\n printf(\"La variabile valore_a e' memorizzata in %#x \\n\", &valore_a);\r\n\r\n printf(\"La variabile ptr1 vale (punta a) %#x \\n\", ptr1);\r\n\r\n printf(\"La variabile ptr1 e' memorizzata in %#x \\n\", &ptr1);\r\n\r\n\/\/ non confondiamo l'indirizzo al quale \u00e8 memorizzato il puntatore con    \/\/l'indirizzo al quale punta, queste righe evidenziano la differenza.\r\n\r\n}\r\n<\/pre>\n
Copiate e compilate questo codice, studiate i commenti e parliamone sul forum.<\/p>\n
Concludo questa importante lezione proponendo qualche esercizio:<\/p>\n
    \n
  1. Scrivere un programma C che dopo aver dichiarato 3 interi e tre puntatori ad intero gli assegni dei valori arbitrari agli interi e poi calcoli il massimo utilizzando i puntatori e non le variabili intere.<\/li>\n
  2. Che cosa succede se scrivo:\n
    \r\nint *ptr1;\r\n\r\nptr1 = &ptr1;\r\n<\/pre>\n<\/li>\n
  3. Dati queste dichiarazioni:\n
    \r\nint *p;\r\nint i;\r\nint k;\r\ni = 42;\r\nk = i;\r\np = &i;\r\n<\/pre>\n
    se volessi portare il valore di i a 75 quale operazione dovrei eseguire?<\/p>\n
    \r\n    k = 75;\r\n    *k = 75;\r\n    p = 75;\r\n    *p = 75;\r\n    due o pi\u00f9 delle precedenti risposte.\r\n<\/pre>\n<\/li>\n
  4. Le seguenti dichiarazioni sono corrette? Fornire spiegazioni adeguate:\n
    \r\nchar c = 'A';\r\ndouble *p = &c;\r\n<\/pre>\n<\/li>\n<\/ol>\n
    Credo che per questa lezione sia abbastanza \ud83d\ude42
    \nAlla prossima!<\/p>\n
    Letture consigliate:<\/h4>\n
    \"C-Corso-Completo-di-Programmazione-kernighan-ritchie-devAPP\"<\/a> Il linguaggio C. Principi di programmazione e manuale di riferimento (Accademica) <\/strong><\/a>
    \nBrian W. Kernighan – Dennis M. Ritchie<\/em>
    \nEditore:<\/strong> Pearson | Lingua:<\/strong> Italiano | Brossura:<\/strong> 313 pagine
    \nPrezzo Listino:<\/strong> EUR 27,00<\/del>
    \nPrezzo Promozione:<\/strong> EUR 22,95 con Spedizione gratuita<\/p>\n
    \"C-Corso-Completo-di-Programmazione-Deitel-Deitel-devAPP\"<\/a> C. Corso completo di programmazione<\/strong><\/a>
    \nPaul J. Deitel – Harvey M. Deitel<\/em>
    \nEditore:<\/strong> Apogeo | Lingua:<\/strong> Italiano | Brossura:<\/strong> 640 pagine
    \nPrezzo Listino:<\/strong> EUR 39,00<\/del>
    \nPrezzo Promozione:<\/strong> EUR 33,15 con Spedizione gratuita<\/p>\n

    \n    \"\"<\/a>
    \n<\/center><\/p>\n","protected":false},"excerpt":{"rendered":"
    Ed eccoci arrivati all’argomento che per tanti utenti rappresenta la “bestia nera” della programmazione in C, i…<\/p>\n","protected":false},"author":53,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[569],"tags":[593,588,724,723,737,241],"class_list":["post-6829","post","type-post","status-publish","format-standard","hentry","category-corso-completo-di-c","tag-corso-completo-di-c-2","tag-corso-di-c","tag-esempi-codice-programmazione-c","tag-esercizi-programmazione-c","tag-i-puntatori-in-c","tag-ignazio-calo"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6829","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/users\/53"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/comments?post=6829"}],"version-history":[{"count":7,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6829\/revisions"}],"predecessor-version":[{"id":7816,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6829\/revisions\/7816"}],"wp:attachment":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/media?parent=6829"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/categories?post=6829"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/tags?post=6829"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}