{"id":6883,"date":"2011-05-06T14:52:05","date_gmt":"2011-05-06T12:52:05","guid":{"rendered":"http:\/\/www.devapp.it\/wordpress\/?p=6883"},"modified":"2011-10-05T12:25:12","modified_gmt":"2011-10-05T10:25:12","slug":"13-i-puntatori-array-matrici-e-aritmetica-dei-puntatori-parte-2","status":"publish","type":"post","link":"https:\/\/www.devapp.it\/wordpress\/13-i-puntatori-array-matrici-e-aritmetica-dei-puntatori-parte-2\/","title":{"rendered":"13. I Puntatori – Array, matrici e aritmetica dei puntatori – parte 2"},"content":{"rendered":"

\"corso-completo-c-i-puntatori-parte-2-vettori-matrici-array-00\"<\/a> Ciao a tutti, in questa nuova lezione del nostro corso completo di programmazione in C approfondiremo lo studio dei puntatori iniziato nella precedente lezione<\/a>.
\nOggi esamineremo l’utilizzo dei puntatori come parametro per le funzioni e come base per la creazione di array e matrici.<\/p>\n

 <\/p>\n

<\/p>\n

Puntatori come parametri<\/h4>\n

Quando nella lezione 11 abbiamo parlato delle funzioni abbiamo specificato che il C utilizza il passaggio dati per valore, questo significa che quando il programma esegue una funzione e passa una variabile come parametro, questa viene copiata ed utilizzata all’interno della funzione. Quando la funzione arriva al termine la copia del dato viene semplicemente cancellata. Questo \u00e8 il motivo per il quale effettuare una modifica al valore di una variabile all’interno di una funzione non cambia il valore che questa variabile ha all’esterno della funzione, perch\u00e9 tutte le modifiche vengono effettuate su una copia del dato.<\/p>\n

Ma non avevamo ancora fatto i conti con i puntatori!<\/p>\n

Infatti l’utilizzo dei puntatori permette di scavalcare in modo molto elegante questa limitazione.<\/p>\n

Cosa succede se una funzione accetta come parametro un puntatore? prendiamo ad esempio la stessa funzione “incrementa” vista nella lezione 11<\/a> e modifichiamola per accettare come parametro un puntatore e non pi\u00f9 un intero. Il codice interno della funzione deve essere modificato per tenere conto di questa differenza, otteniamo quindi questo codice:<\/p>\n

\r\nvoid incrementa(int *value) {\r\n\r\n        *value = *value + 10;\r\n\r\n}\r\n<\/pre>\n
Quando questa funzione verr\u00e0 richiamata dal programma principale, il parametro verr\u00e0 copiato come sempre, ma questa volta viene effettuata una copia di un puntatore quindi il valore puntato \u00e8 sempre lo stesso, non ci sono copie, quindi tutte le modifiche apportate al valore puntato all’interno della funzione saranno visibili anche fuori.<\/p>\n
Se invece volessimo modificare il valore del puntatore (e non della cella puntata dal puntatore) ci troveremmo con il medesimo problema di prima, ovvero che la modifica effettuata verrebbe persa al termine della funzione, perch\u00e9 la funzione lavora su una copia del puntatore.<\/p>\n
Possiamo quindi eseguire l’intero programma:<\/p>\n
\r\n#include \r\n\r\nvoid incrementa(int *value) {\r\n\r\n        *value = *value + 10;\r\n\r\n}\r\n\r\nint main (int argc, const char * argv[])\r\n\r\n{\r\n\r\n        int k = 5;\r\n\r\n        int *p = &k;\r\n\r\n        printf(\"Valore prima di eseguire incrementa %d\\n\",k);\r\n\r\n        incrementa(p);\r\n\r\n        printf(\"Valore dopo aver eseguito incrementa %d\\n\",k);\r\n\r\n          return 0;\r\n\r\n}\r\n<\/pre>\n
Questa volta notiamo che la fuzione ha effettivamente modificato il valore della variabile K<\/em>.<\/p>\n
Tutto chiaro? facciamo ancora una piccola modifica, come notate io ho scritto:<\/p>\n
\r\nint *p = &k;\r\n\r\nincrementa(p);\r\n<\/pre>\n
Possiamo sfruttare una sorta di “propriet\u00e0 transitiva” e richiamare la funzione direttamente tramite:<\/p>\n
\r\nincrementa(&k);\r\n<\/pre>\n
Questo perch\u00e9 il parametro che la funzione richiede \u00e8 un int*<\/em> che di fatto \u00e8 un indirizzo, &k<\/em> \u00e8 anch’esso un indirizzo quindi il passaggio \u00e8 lecito.<\/p>\n
Concludo questa prima parte della lezione con delle domande:<\/p>\n
    \n
  1. Modificare questa funzione utilizzando i puntatori piuttosto che gli interi:\n
    \r\nint max(int x, int y) {\r\n\r\n        if (x <= y) {\r\n\r\n   return x;\r\n\r\n}\r\n\r\nelse {\r\n\r\n        return y;\r\n\r\n}\r\n\r\n}\r\n<\/pre>\n<\/li>\n
  2. la precedente funzione restituisce un intero, \u00e8 utile\/necessario che la sua versione che opera con i puntatori restituisca un puntatore?<\/li>\n
  3. Quale tra questi \u00e8 il modo corretto di richiamare la seguente funzione:\n
    \r\nint funzioneEsercizio(int a, int b, int *c, int *d)\r\n<\/pre>\n
    a) <\/p>\n
    \r\nint a, b, c, d;\r\n\r\n        funzioneEsercizio(a,b,c,d);\r\n<\/pre>\n
    b) <\/p>\n
    \r\n        int a, b, c, d;\r\n\r\n        funzioneEsercizio(a, b, &c, &d);\r\n<\/pre>\n
    c) <\/p>\n
    \r\n        int a, b, *c, *d;\r\n\r\n        funzioneEsercizio(*a, *b, &c, &d);\r\n<\/pre>\n<\/li>\n<\/ol>\n
    Array, matrici e aritmetica dei puntatori<\/h4>\n
    In alcuni casi pu\u00f2 essere utile all'interno del nostro codice raggruppare le variabili in \"gruppi\" ed accedere alle singole variabili tramite il nome del gruppo ed un indice numerico. Detta cos\u00ec pu\u00f2 sembrare una cosa campata in area, ma poter accedere ad una serire di variabili utilizzando un indice numerico offre veramente infinite possibilit\u00e0, che al contrario con le variabili \"normali\" non abbiamo. Qualche esempio? Possiamo accedere alle variabili in ordine dentro un ciclo for<\/em>, semplicemente prendendo come indice l'indice dell'iterazione...vedremo pi\u00f9 avanti qualche esempio di utilizzo.<\/p>\n
    Un array (detto anche vettore) \u00e8 una struttura dati basilare, le strutture dati sono, appunto, strutture di variabili aggregate che in qualche modo ci aiutano a rappresentare meglio un problema all'interno del programma. Esistono strutture dati pi\u00f9 o meno complesse, ma forse la pi\u00f9 semplice di tutte \u00e8 proprio l'array.<\/p>\n
    Un array \u00e8 un insieme di variabili dello stesso tipo, ciascuna \u00e8 accessibile tramite il nome dell'array e l'indice della sua posizione.<\/p>\n
    Per matrice invece si intende di norma una struttura bidimensionale, in cui le singole variabili sono raggiunte tramite una coppia di interi che rappresentano la coppia riga\/colonna, avete presente battaglia navale? In C praticamente \u00e8 pensata come un array...le cui singole variabili non siano interi o caratteri, ma a loro volta altri array.<\/p>\n

    \n\"corso-completo-c-i-puntatori-parte-2-vettori-matrici-array-01\"<\/a>
    \n<\/center><\/p>\n
    Possiamo creare una matrice con un numero qualsiasi di dimensioni, certo fino ad una matrice a 3 dimensioni possiamo anche disegnarla, ma una a 4, 5, n dimensioni \u00e8 costretta a stare solo nella nostra testa. Quello che cambia a livello teorico \u00e8 che in una matrice ad n-dimensioni per accedere alla variabile mantenuta al suo interno abbiamo bisogno di n indici.<\/p>\n
    Ovviamente l'analogia con la matematica \u00e8 forte, chi ha studiato un p\u00f2 di analisi all'universit\u00e0 sa che un elemento in uno spazio n-dimensionale \u00e8 univocamente identificato da una n-upla ordinata di elementi, ma non addentriamoci troppo nel matematichese \ud83d\ude42<\/p>\n
    Per dichiarare un array in C \u00e8 sufficiente inserire il numero degli elementi che costituir\u00e0 l'array tra parentesi quadra subito dopo il nome della variabile. Ad esempio se vogliamo dichiarare un array di dieci numeri interi baster\u00e0 scrivere:<\/p>\n
    \r\nint mioArray[10];\r\n<\/pre>\n
    Mentre per accedere alle singole variabili che costituiscono l'array baster\u00e0 inserire l'indice corrispondente tra parentesi quadre.<\/p>\n
    \r\nmioArray[5] = 42; \/\/assegna il valore 42 all'elemento in posizione 5 dell'array.\r\n<\/pre>\n
    ATTENZIONE:<\/strong> Va sottolineato che in C gli array sono \"zero based\" il che significa che il primo elemento avr\u00e0 come indice di posizione zero. Quindi gli elementi di mioArray sono accessibili da:<\/p>\n
    \r\nmioArray[0];\r\n\r\n\/\/fino a\r\n\r\nmioArray[9];\r\n<\/pre>\n
    Per dichiarare una variabile a due dimensioni si utilizza una sintassi molto simile, che si ripete poi identica per le matrici ad n dimensioni. Per una matrice bidimensionale costituita da 10 righe e 5 colone basta scrivere:<\/p>\n
    \r\nint miaMatrice[10][5]; \/\/dichiara una matrice composta 10 righe e 5 colonne.\r\n<\/pre>\n
    e per accedere all'elemento alla riga 3, colonna 4 baster\u00e0 scrivere:<\/p>\n
    \r\nmiaMatrice[3][4];\r\n<\/pre>\n
    ATTENZIONE: <\/strong>nche in questo caso ricordiamo che la prima riga (e la prima colonna) hanno indice zero.<\/p>\n
    Per dichiarare una matrice a 3 dimensioni scriveremo:<\/p>\n
    \r\nint miaMatrice[10][10][10];\r\n<\/pre>\n
    Vi assicuro che difficilmente vi troverete ad utilizzare matrici a pi\u00f9 di tre dimensioni..<\/p>\n
    Notare che gi\u00e0 la sintassi spiega che parlare di matrice bidimensionale equivale a parlare di un array di array, una matrice tridimensionale \u00e8 un array di matrici bidimensionali e cos\u00ec via.<\/p>\n
    Facciamo un piccolo esempio sull'utilizzo degli array e delle matrici, scriviamo un programma che dichiari e inizializzi un array di 10 elementi ed una matrice 5x5 e poi ne visualizzi a video i valori.<\/p>\n
    \r\n#include \r\n\r\nint main(int argc, char **argv){\r\n\r\n int mioArray[10];\r\n\r\n int miaMatrice[5][5];\r\n\r\n int i,j; \/\/una variabile temporanea, mi serviranno per i cicli for.                                                      \r\n\r\n \/* inizializzo l'array, utilizzo un ciclo ed assegno ad ogni variabile                                                  \r\n\r\n *  un valore pari alla sua posizione + 100;                                                                              \r\n\r\n *\/\r\n\r\n for (i = 0; i < 10; i++ ){\r\n\r\n   mioArray[i] = i + 100;\r\n\r\n }\r\n\r\n \/\/visualizzo l'array a schermo                                                                                          \r\n\r\n for (i = 0; i < 10; i++ ){\r\n\r\n   printf(\"%d \", mioArray[i]);\r\n\r\n }\r\n\r\n printf(\"\\n\");\r\n\r\n \/* inizializzo la matrice utilizzando due cicli for annidati.                                                            \r\n\r\n  * in ogni valore inserisco il prodotto riga * colonna                                                                  \r\n\r\n  *\/\r\n\r\n for (i = 0; i < 5; i++) {\r\n\r\n   for (j = 0; j < 5; j++) {\r\n\r\n     miaMatrice[i][j] = i * j;\r\n\r\n   }\r\n\r\n \r\n\r\n \/* Visualizzo la matrice a schermo                                                                                        \r\n\r\n  *                                                                                                                        \r\n\r\n  *\/\r\n\r\n for (i = 0; i < 5; i++) {\r\n\r\n   for (j = 0; j < 5; j++) {\r\n\r\n     printf(\"%d \",miaMatrice[i][j]);\r\n\r\n   }\r\n\r\n   printf(\"\\n\");\r\n\r\n }\r\n\r\n return 0;\r\n\r\n}\r\n<\/pre>\n
    Avete notato com'\u00e8 facile accedere quindi alle variabili tramite un indice? in questo modo possiamo scorrere tutto l'array o la matrice con dei semplici cicli for.<\/p>\n
    In questo esempio abbiamo inizializzato i valor dell'array tramite un ciclo for, esiste una sintassi alternativa che \u00e8 la seguente<\/p>\n
    \r\nint mioArray[10] = {100,101,102,103,104,105,106, 107, 108, 109};\r\n<\/pre>\n
    Questa sintassi \u00e8 utilizzabile solo in fase di dichiarazione dell'array, non \u00e8 possibile utilizzarla altrove.<\/p>\n
    Ovviamente gli array non servono solo ad essere ciclati dentro un for, ma sono una vera e propria struttura dati utile per rendere il nostro codice pi\u00f9 semplice, facciamo un'altro piccolo esempio: supponiamo di voler scrivere una funzione che restituisca il numero dei giorni del mese passato come parametro.<\/p>\n
    Per semplificare diciamo che la nostra funzione accetter\u00e0 come parametro un intero che rappresenta il numero del mese (gennaio = 1, febbraio = 2 ...etc etc).<\/p>\n
    Un approccio \"ingenuo\" potrebbe essere il seguente:<\/p>\n
    \r\nint giorniDelMese(int mese) {\r\n\r\n        if (mese == 0){\r\n\r\n                return 31;\r\n\r\n}\r\n\r\n        else if (mese == 2) {\r\n\r\n                return 29;\r\n\r\n}\r\n\r\nelse if (mese == 3) {\r\n\r\n        return 31;\r\n\r\n}\r\n\r\n}\r\n<\/pre>\n
    Oppure magari siete gi\u00e0 un p\u00f2 pi\u00f9 esperti ed avete pensato a qualcosa come:<\/p>\n
    \r\nint giorniDelMese(int mese) {\r\n\r\n        if (mese == 1 || mese == 3 || mese == 5 || mese == 7 || mese == 8 || mese == 10 || mese == 13) {\r\n\r\n                return 31\r\n\r\n}\r\n\r\n        else if (mese == 4 ||  mese == 6 || mese == 9 || mese == 11 ) {\r\n\r\n        return 30;\r\n\r\n}\r\n\r\nelse {\r\n\r\n        return 29;\r\n\r\n}\r\n\r\n}\r\n<\/pre>\n
    ..ma non sarebbe pi\u00f9 bella da leggere se fosse scritta in questo modo: ?<\/p>\n
    \r\nint giorniDelMse (int mese) {\r\n\r\n        int giorniDeiMesi[12] = {31,29,31,30,31,30,31,31,30,31,30,31}\r\n\r\n        return giorniDeiMesi[mese - 1];\r\n\r\n}\r\n<\/pre>\n
    Semplice e chiara... notare che abbiamo digitato [mese -1] perch\u00e9 gli array sono \"zero based\" mentre come da specifiche abbiamo detto che gennaio =1, febbraio = 2 etc.<\/p>\n
    Vi state chiedendo perch\u00e9 io abbia deciso di inserire questo argomento nel capitolo dei puntatori? Bene, adesso allora \u00e8 il momento (come diceva un autore di cui non ricordo il nome) di mettere al cervello gli scarponi da arrampicata, perch\u00e9 il percorso si fa un p\u00f2 arduo (contenti? :P)<\/p>\n
    Un'informazione preliminare: gli array in C sono memorizzati in celle di memoria contigue, un array composto da 10 interi occoper\u00e0 quindi 40 byte consecutivi all'interno della memoria del nostro calcolatore. Questa informazione ci torner\u00e0 utile tra un attimo, dopo che avremo parlato dell'aritmetica dei puntatori.<\/p>\n
    Con i puntatori \u00e8 possibile svolgere delle operazioni aritmetiche un p\u00f2 particolari, supponiamo di avere un puntatore ad intero che punti all'allocazione di memoria numero 100, se sommiamo a questo puntatore un intero, ad esempio 5, il risultato non sar\u00e0 105 come ci si potrebbe aspettare ma l'operazione effettuata sar\u00e0 in realt\u00e0  100 + 5 * il numero di byte che costituiscono il tipo del puntatore (in questo caso 4byte perch\u00e8 puntatore ad intero) quindi il risultato sar\u00e0 120. Quello che abbiamo ottenuto in pratica \u00e8 di far puntare il puntatore 5 \"passi\" pi\u00f9 avanti nella memoria.<\/p>\n
    La definizione di wikipedia \u00e8 molto pi\u00f9 formale:<\/p>\n
    L'operatore di somma di puntatore e intero richiede un operando di tipo puntatore e un operando di tipo intero. Il risultato della somma \u00e8 l'indirizzo dato dal puntatore incrementato del risultato della moltiplicazione dell'intero specificato per la dimensione (sizeof) del tipo base del puntatore espressa in byte. Per esempio, se p \u00e8 un puntatore al tipo intero int (int *p) di valore 1000 (p=1000), e se la dimensione di un int \u00e8 quattro byte, p+1 vale 1004, p+2 vale 1008, e in generale p+n vale 1000+n*2.<\/p><\/blockquote>\n
    Quindi, date queste due ultime informazioni, se conoscessimo l'indirzzo \"di partenza\" di un array potremmo accedere ai suoi valori non tramite la sintassi con gli indici, ma tramite operazioni dirette con i puntatori.<\/p>\n
    Infatti \u00e8 proprio quello che avviene! La dichiarazione di un array con l'istruzione:<\/p>\n
    \r\nint mioArray[10];\r\n<\/pre>\n
    Si occupa di riservare 10 * 4 byte = 40 byte di memoria consecutiva e memorizza nella variabile mioArray (senza parentesi quadre) l'indirizzo di partenza di questo blocco di celle.<\/p>\n
    Quindi mioArray, \u00e8 a tutti gli effetti un puntatore ad intero, soltanto che grazie a questa sintassi, il compilatore ha riservato lo spazio per lui e per altri 9 come lui.<\/p>\n
    Come abbiamo detto precedentemente, sommando un intero a mioArray posso muovermi all'interno della memoria a step di un intero, se volessi infatti leggere l'intero memorizzato nella prima posizione dell'array (la posizione zero) basterebbe leggere il valore contenuto in<\/p>\n
    \r\nmioArray + 0\r\n<\/pre>\n
    se volessi invece leggere il valore contenuto nella seconda posizione basterebbe leggere il valore contenuto in<\/p>\n
    \r\nmioArray + 1\r\n<\/pre>\n
    Ricordiamoci per\u00f2 che per leggere il valore della memoria all'indirizzo puntato da un puntatore \u00e8 necessario l'operatore di dereferenziazione  \" * \" quindi per stampare il valore contenuto nella posizione n<\/em> dell'array dovremo scrivere:<\/p>\n
    \r\nprintf(\"Il valore \u00e8: %d\", *(mioArray + n));\r\n<\/pre>\n
    Le parentesi son d'obbligo perch\u00e9 l'operatore di dereferenziazione ha la stessa priorit\u00e0 del \" + \" ma l'associativit\u00e0 \u00e8 a destra quindi se le omettessi il risultato sarebbe errato.<\/p>\n
    Vediamo in questo piccolo esempio come utilizzare indifferentemente gli array tramite indici e tramite aritmetica dei puntatori:<\/p>\n
    \r\n#include \r\n\r\nint main(int argc, char **argv) {\r\n\r\n int i; \/\/variabile da usare nei cicli for                                                                                \r\n\r\n \/* Dichiaro un array composto da 5 interi                                                                                \r\n\r\n  * e lo inizializzo con la sintazzi \"veloce\"                                                                              \r\n\r\n  *\/\r\n\r\n int mioArray[5] = {99,98,97,96,95};\r\n\r\n \/* Accedo all'array per visualizzare i dati tramite gli indici                                                            \r\n\r\n  *\/\r\n\r\n for (i = 0; i < 5; i++){\r\n\r\n   printf(\"In posizione %d l'array contiene: %d\\n\", i, mioArray[i]);\r\n\r\n }\r\n\r\n \/* Eseguo l'operazione identica utilizzando per\u00f2                                                                          \r\n\r\n  * l'artimetica dei puntatori                                                                                            \r\n\r\n  *\/\r\n\r\n for (i = 0; i < 5; i++){\r\n\r\n   printf(\"In posizione %d l'array contiene: %d\\n\", i, *(mioArray + i));\r\n\r\n }\r\n\r\n}\r\n<\/pre>\n
    Il passo finale<\/h4>\n
    Adesso siete pronti per un piccolissimo sforzo finale, comprendere come strutture come array e matrici possono essere passate ad una funzione come parametro.<\/p>\n
    Tutto quello che bisogna sapere \u00e8 gi\u00e0 stato detto in questo capitolo, bisogna solo farci attenzione.<\/p>\n
    Abbiamo visto come si passa un puntatore ad una funzione e abbiamo scoperto che un array non \u00e8 altro che un puntatore al quale \u00e8 stato riservato dello spazio in pi\u00f9, bene, a questo punto, per scrivere una funzione che accetti come parametro un array, occorre semplicemente scrivere una funzione che accetti un puntatore come parametro.<\/p>\n
    Purtroppo c'\u00e8 una limitazione, considerando quanto abbiamo visto fino ad ora la funzione non pu\u00f2 sapere, soltanto esaminando il puntatore, quant'\u00e8 grande l'array, quindi occorrer\u00e0 utilizzare uno stratagemma. Per questo ci sono diverse scuole di pensiero: qualcuno inserisce un valore particolare alla fine dell'array per \"accorgersi\" quando l'array \u00e8 finito, altri (come me) passano alla funzione anche la dimensione dell'array. Vediamo in questo esempio la creazione della funzione \"printArray\":<\/p>\n
    \r\n#include \r\n\r\nvoid printArray(int *array, int size){\r\n\r\n int i;\r\n\r\n for (i = 0; i < size; i++ ){\r\n\r\n   printf(\"%d \", array[i]);\r\n\r\n }\r\n\r\n printf(\"\\n\");\r\n\r\n}\r\n\r\nint main(int argc, char **argv) {\r\n\r\n int i; \/\/variabile da usare nei cicli for                                                                                \r\n\r\n \/* Dichiaro un array composto da 5 interi                                                                                \r\n\r\n  * e lo inizializzo con la sintazzi \"veloce\"                                                                              \r\n\r\n  *\/\r\n\r\n int mioArray[5] = {99,98,97,96,95};\r\n\r\n printArray(mioArray, 5);\r\n\r\n}\r\n<\/pre>\n
    Per questa lezione vi risparmio gli esercizi, mi aspetto per\u00f2 che chi vuol imparare sul serio si metta a studiare per bene queste ultime lezioni e a provare il codice fino a prendere dimestichezza con i concetti presentati.<\/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":"
    Ciao a tutti, in questa nuova lezione del nostro corso completo di programmazione in C approfondiremo lo…<\/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":[741,738,593,588,724,723,737,241,739,740],"class_list":["post-6883","post","type-post","status-publish","format-standard","hentry","category-corso-completo-di-c","tag-aritmetica-dei-puntatori-c","tag-array-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","tag-matrici-c","tag-vettori-c"],"acf":[],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6883","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=6883"}],"version-history":[{"count":9,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6883\/revisions"}],"predecessor-version":[{"id":7817,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/posts\/6883\/revisions\/7817"}],"wp:attachment":[{"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/media?parent=6883"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/categories?post=6883"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devapp.it\/wordpress\/wp-json\/wp\/v2\/tags?post=6883"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}