Newsgroup: it.comp.lang.c
Titolo: passaggio di array multidimensionali

domanda banale: cos'ha di sbagliato questo codice?
#define MAX 10
void f(int a[MAX][MAX]);
int main(){
    int a[4][3];
    f(a);
}
void f(int a[MAX][MAX]){ /* ... */ }
il compilatore mi dà il seguente warning:
$ gcc test.c
test.c: In function ‘main’:
test.c:8: warning: passing argument 1 of ‘f’ from incompatible pointer
type
grazie

ludovicovan ha scritto:

La dimensione dell'array passato: gli array sono locazioni consecutive di 
memoria: la funzione si aspetta una "riga" ogni MAX elementi, mentre le 
"righe" di ciò che gli passi tu hanno solo 4 elementi. E si lamenta. Non 
escludo che quel codice possa dare problemi di esecuzione a runtime, 
oltre al warning.

 oltre al warning.
Ok, in effetti questo ha senso.
Allora qual è il modo migliore per scrivere una funzione che operi su
matrici di qualsiasi dimensione (o meglio: di qualsiasi dimensioni
minori di un certo valore MAX)?
grazie

 grazie
Prova a fare in modo che la tua funzione prenda come argomenti un 
puntatore ad int** se la tua matrice è di int, e due parametri che ne 
specifichino le dimensioni, poi dereferenzi il puntatore "a mano" usando 
le dimensioni specificate come parametro.

 le dimensioni specificate come parametro.
Chiedo venia, la tarda ora mi fece postare in errore. Direi che così va 
meglio:
#include <stdio.h>
void f(char*, int, int);
int main()
{
  char a[2][3] = {'a','b','c',
                  'd','e','f'};
  char b[3][4] = {'a','b','c','d',
                  'e','f','g','h',
                  'i','l','m','n'};
  f((char*)a, 2, 3); // ok
  f(b, 3, 4); // warning
  return 0;
}
void f(char* p, int r, int c)
{
  int i, j;
  for (i = 0; i < r; ++i)
  {
    for (j = 0; j < c; ++j)
      putchar(*(p + c * i + j));
    putchar('\n');
  }
}
Il cast rimuove il warning che altrimenti si ripresenta. Però se le 
dimensioni passate alla funzione sono corrette, la funzione non dà 
problemi. Non è sicuro nè tantomeno estetico, ma funziona.
Saluti.

 Saluti.
Il warning è dovuro al fatto che hai dichiarato il parametro come char * 
ma stai passando un char **. Penso che la cosa più corretta sarebbe 
stata mettere char ** come parametro della funzione!

 mettere char ** come parametro della funzione!
entrambe sbagliate:
non sta pasando un char** ma un char *[n]
con char** come parametro non ci puoi leggere un array bidimensionale di 
char, perche' con char** il tipo di dato puntato dal parametro e' un 
pointer, mentre il tipo puntato dal parametro passato e' un char. 

 dal parametro passato e' un char.
Era a questo che mi riferivo con l'"errata corrige". Credo che usare un 
char** venga intuitivo ma all'atto pratico scomodo. Il tipo char* fa il 
suo lavoro abbastanza bene se usato con cura; tra l'altro l'autore del 
post chiedeva come fare a maneggiare tabelle variabili...
Per una soluzione più elegante pensavo a una struct in cui mettere un 
char* che punti a un blocco di m*n char allocato dinamicamente e i 
medesimi m e n (numero di righe e di colonne) e passare tutto alla 
funzione.
Saluti!


la tua soluzione e' corretta cosi' come l'hai scritta, e risolve il problema 
posto dall' OP.
se il parametro della funzione diventa un char** non puoi passargli un array 
bidimensionale, ma anche nel main devi dichiarare l'array come vettore di 
pointer (ad altri array), sono 2 tipi di dato diversi.