Ciao a tutti,
chiedo a tutti scusa in anticipo per il post un po' lungo e forse per molti un po' noioso. Ma un vostro contributo, sarebbe davvero utile per migliorare la mia comprensione su determinati argomenti.
Proseguendo nello studio e nell'approfondimento del C è giunto il momento degli array multidimensionali.
Se da una parte i concetti teorici mi sembrano sufficientemente chiari, dall'altra ho qualche dubbio nella fase di scrittura del codice. Evidentemente la premessa che tutto mi è sufficientemente chiaro probabilmente è fala.
Provo a fare una sorta di premessa: in definitiva un array multidimensionale è un puntatore ad n array. Ad esempio il seguente array bidimensioneale:
int matrice[2][3];
Può essere pensato come int (*matrice)[3]. In definitiva si potrebbe dire che un array multidimensionale è sempre un array monodimensionale.
Adesso, per addentrarmi nei miei dubbi, assegno all'array matrice dei valori:
static int matrice[2][3] = {{1,2,3},{4,5,6}};
Dal momento che il nome di un array ne definisce il puntatore dovrei poter scrivere la seguente funzione per stampare l'array bidimensionale sopra dichiarato.
void stampaUno(int v[], int dimCol)
{
for(int c = 0; c < dimCol; c++)
{
printf("%d ", v[c]);
}
printf("\n");
}
Come vederemo nella main ogni volta che verrà invocata la funzione stampaUno il puntatore v sarà incrementato alla i-esima riga dell'array bidimensionale.
La funzione stampaUno funziona correttamente e non viene segnalato niente di anomalo come previsto.
Se è vero che il nome di un vettore è un puntatore allora è possibile definire la funzione stampaDue:
void stampaDue(int* v, int dimCol)
{
for(int c=0;c<dimCol;c++)
{
printf("%d ", v[c]);
}
printf("\n");
}
Tuttavia, pur andando a buon fine la compilazione e funzionando correttamente, in fase di compilazione ottengo il seguente warning "warning: passing argument 1 of 'stampaDue' from incompatible pointer type" quando effettuo la chiamata:
for(int i=0;i<2;i++){
stampaDue(matrice+i, 3);
}
Mi sfugge il motivo eppure dovrebbe essere un corretto puntatore rispetto alla definizione della funzione. In effetti, in fase di dichiarazione del prototipo l'IDE mi dà il seguente messaggio:
"int *' but argument is of type 'int (*)[3]", probabilmente mi vuol indicare che in quel modo ho un puntatore ad array la cui lunghezza sarebbe varibaile, ma ne mio caso essa è costante a tre? In definitiva è sbagliata tale funzione, seppur funzionante?
A questo punto dichiaro una funzione del tutto simile a stampaUno ma con un'invocazione leggermente diversa.
void stampaTre(int v[], int dimCol)
{
for(int c=0;c<dimCol;c++)
{
printf("%d ", v[c]);
}
printf("\n");
}
La sua invocazione a questo punto viene effettuata nel seguente modo:
for(int i=0;i<2;i++)
{
stampaTre((vettBid+i), 3); /** Passo il puntatore incrementano le righe **/
}
Pur funzionando anche questa implementazione, in fase di compilazione, ottengo il seguente messaggio:
"note: expected 'int *' but argument is of type 'int (*)[3]" alla riga della definizione del prototipo della funzione.
void stampaTre(int v[], int dimCol);
Anche in questo caso devo intendere la notifica come l'ho interpreta poco sopra?
Faccio presente però che il prototipo è identico alla funzione stampaUno, il quale prototipo non scatena alcun messaggio.
Noto però che se commento la riga dell'invocazione della funzione
stampaTre((vettBid+i), 3);
Il messaggio scompare.
Infine, ho scritto una quarta dichiarazione di funzione "stampaQuattro", la quale dovrebbe essere quella "migliore" che riporto di seguito, ma all'interno della quale non capisco come si acceda e si utlizzi:
void stampaQuattro(int (*matrice)[3], int dimCol)
{
for(int c=0;c<dimCol;dimCol++)
{
printf("%d ", *matrice[c]);
}
printf("\n");
}
Detto questo, vi sarò grato delle considerazioni che vorrete fornirmi circa i miei dubbi e su quanto ho implementato. E se si può concludere che un array MULTI-dimensionale può essere ricondotto a un array monodimensione che punta ad N puntatori di dimensione D. In altre parole un putatore che punta N puntatori di dimensione D. Pertanto, nel caso di un array bidimensionale sarà possibile inoltrare l'interno array bidimensionale a[R][C] una funzione passando a[C].
Mi pare di capire che per poter lavorare in questo modo le funzioni devono poter conoscere a priori le dimensioni degli array. Infine, non esiste un modo per capire se iterano il puntatore a si è arrivati all'ultima riga, corretto? Rafforzando l'idea che le dimensioni devono essere ben note a priori.
Di segutio, per semplicità, riporto il piccolo codice di prova che ho effettuato.
#include <stdio.h>
#include <stdlib.h>
static int matrice[2][3] = {{1,2,3},{4,5,6}};
void stampaUno(int v[], int dimCol);
void stampaDue(int* v, int dimCol);
void stampaTre(int v[], int dimCol);
void stampaQuattro(int (*v)[3], int dimCol);
int main(int argc, char** argv) {
for(int i=0;i<2;i++){
stampaUno(matrice[i], 3);
}
printf("stampa DUE\n");
for(int i=0;i<2;i++){
stampaDue(matrice+i, 3);
}
printf("stampa TRE\n");
for(int i=0;i<2;i++)
{
stampaTre((matrice+i), 3);
}
printf("stampa QUATTRO\n");
for(int i=0;i<2;i++)
{
stampaQuattro((matrice+i), 3);
}
return (EXIT_SUCCESS);
}
void stampaUno(int v[], int dimCol)
{
for(int c = 0; c < dimCol; c++)
{
printf("%d ", v[c]);
}
printf("\n");
}
void stampaDue(int* v, int dimCol)
{
for(int c=0;c<dimCol;c++)
{
printf("%d ", v[c]);
}
printf("\n");
}
void stampaTre(int v[], int dimCol)
{
for(int c=0;c<dimCol;c++)
{
printf("%d ", v[c]);
}
printf("\n");
}
void stampaQuattro(int (*matrice)[3], int dimCol)
{
for(int c=0;c<dimCol;c++)
{
printf("%d ", (*matrice)[c]);
}
printf("\n");
}
Ancora grazie infinite a tutti, per il vostro prezioso contributo che mi consente spesso una migliore comprensione delle cose.