Newsgroup: it.comp.lang.c++
Titolo: Passaggio di array multidimensionale a funzione

 
 Per quanto ho capito al  link:
 
http://cplusplus.com/doc/tutorial/arrays/
 
 
...il passaggio di un'array ad una funzione avviene per *riferimento*,
in
quanto, l'array stesso, e' per definizione, un puntatore costante che
punta al *primo elemento dell'array*; quindi,alla funzione, passiamo
per
riferimento, un puntatore al primo elemento dell'array.
 
Per quanto sopra, dobbiamo, con qualche artificio, passare il numero
di elementi che compone l'array, alla funzione.
 
Quando invece lavoro con array a piu' dimensioni, allora, e'
solo il numero di righe a non essere definito
nel passaggio dell'array?
 
Ad es., per  un' array a due dimensioni, si avra' per quanto spiegato
al suddetto link:
 
void procedure (int myarray[][3])
 
...ma come mai invece, viene indicato esplicitamente il numero di
 colonne(pari a 3)?..per  analogia con l'array monodimensionale, NON
 avrei dovuto avere:
 
 void procedure (int myarray[][])
 
Ciao e grazie mille!!!

 Ciao e grazie mille!!!
 
 
-- 
1) Resistere, resistere, resistere.
2) Se tutti pagano le tasse, le tasse le pagano tutti
Soviet_Mario - (aka Gatto_Vizzato)
 

 
 
Allora, cominciamo col dire che un puntatore è un puntatore, un array è un
array: sono due cose diverse.
 
In C si dice che quando si passa un array ad una funzione questo "decade" a
puntatore (al primo elemento). Quando quindi hai una funzione:
void f(int *a);
e la chiami come:
int a[10];
f(a);
stai passando un array e ricevendo un puntatore ad a[0].
 
A questo punto, cosa succede con gli array multidimensionali?
 
Beh, facciamo un passo indietro e vediamo cosa si può fare con un puntatore.
Su un puntatore hai definite le operazioni di + e -, quindi puoi scrivere
cose come:
int *p = &a[1];
p = p+1; // p adesso punta ad a[2];
e questa cosa funziona con puntatori a qualsiasi tipo perché, semplicemente,
il compilatore sa quanto i dati puntati sono grossi e di quante locazioni di
memoria spostare il puntatore.
 
Anche ora, mettiamo insieme i pezzi:
Se hai una funzione:
void a(int arr[][3])
l'operazione di somma è definita, sai di quanto spostare il puntatore in caso
facessi, ad esempio, arr+1 (sposti il puntatore dello spazio necessario a
contenere 3 interi, la dimensione della colonna).
ma se avessi:
void a(int arr[][])
un arr+1 quanto varrebbe? non c'è modo di saperlo!
 
Quindi, per questo, questa sintassi non è accettabile ;)
 
Ciao!


Se ho ben capito, modificando l'esempio al link:
 
http://cplusplus.com/doc/tutorial/arrays/
 
 
abbiamo:
 
===============================================
using namespace std;
 
void printarray (int* p, int length) {
 
  int a ;
 
  for (int n=0; n<length; n++){
 
   cout << *(p+n) << " ";
   cout << "\n";
 
 
  }
 p=&a; //assegno un nuovo indirizzo a p
}
 
int main ()
{
  int firstarray[] = {5, 10, 15};
 
  printarray (firstarray,3);
 
//controllo se firstarray è variato
// al variare di p nella funz. printarray
// e noto che non ci sono variazioni.
 
for (int n=0; n<3; n++){
 
   cout << firstarray[n] << " ";
   cout << "\n";
 
  }
 
  return 0;
}
============================================
 
...quindi, cio' dimostra che il  puntatore e' passato per valore.
 
Volendo passare un'array a due dimensioni, es. , come si imposta il
puntatore nella funzione printarray?
 
Inoltre, al predetto link NON e' spiegato come si inizializza un'array
multidimensione:
 
per un'array monodimensionale, scrivo:
 
int firstarray[] = {5, 10, 15};
 
...ma per un'array ad es. a due dimensioni?
 
Ciao e grazie milleeeee!
 

 ...ma per un'array ad es. a due dimensioni?
 
Al link (sembra un tutorial piu' approfondito):
 
http://www.learncpp.com/cpp-tutorial/65-multidimensional-arrays/
 
 
vengono spiegati piu' in dettaglio gli array multidimensionali.
 
 
Ciao e grazie mille!!!
 
 
 
 
 

============================================
 
in poche parole:
funziona x i puntatori, nn funziona per gli array
 
quello che vuoi � il seguente codice...
#include <iostream>
using namespace std;
 
void printarray (int** p, int length)
{int a, n, *w;
 
 w=*p;
 printf("%x\n", (char*) p);
 for(n=0; n<length; ++n)
         cout << *(w+n) << " ";
 
 cout << "\n";
 *p=&a; //assegno un nuovo indirizzo a p
}
 
int main ()
{int n, firstarray[] = {5, 10, 15}, *z=firstarray;
 
 printf("%x\n", (char*) &z);
 printarray(&z,3);
 
// controllo se firstarray � variato
// al variare di p nella funz. printarray
// e noto che non ci sono variazioni.
 
 for (n=0; n<3; ++n)
   cout << z[n] << " ";
 
 cout << "\n";
 return 0;
}
risultato
12ff44
12ff44
5 10 15
1243628 1245012 4198947
-----------------------------
vi + da calcolare che sarebbe UB il fatto di leggere un array dello
stack nn allocato x il programma al momento dell'operazione [che
invece sembrerebbe allocato lo stesso]
 
quello che nn risulta � invece lo stesso discorso per l'array
firstarray[], in pratica x i puntatori il discorso sembra che si puo'
fare, ma per gli array no...
 
#include <iostream>
using namespace std;
 
void printarray (int** p, int length) 
{int a, n, *w;
 
 w=(int*)p;
 printf("%x\n", w);
 for(n=0; n<length; ++n)
         cout << *(w+n) << " ";
 
 cout << "\n";
 *p=&a; //assegno un nuovo indirizzo a p
}
 
int main ()
{int n, firstarray[] = {5, 10, 15};
 
 printf("%x\n", (char*) &firstarray);
 printarray( (int**)&firstarray,3);
 
// controllo se firstarray � variato
// al variare di p nella funz. printarray
// e noto che non ci sono variazioni.
 
 for (n=0; n<3; ++n)
   cout << firstarray[n] << " ";
 
 cout << "\n";
 return 0;
}
 
-------------
12ff48
12ff48
5 10 15
1244972 10 15
nn funziona..
in pratica nn funziona poiche' firstarray � solo un indirizzo
nn � un indirizzo che contiene un putntatore...
