Oppure

Loading
31/10/10 14:56
Giarados
Postato originariamente da TheKaneB: 
int sizeX = 10;
int sizeY = 10;
int * matrice = malloc(sizeof(*matrice) * sizeX * sizeY);



// al posto di matrice[x][y] = 42;
matrice[x + y*sizeX] = 42;



Non ho capito bene, e più leggo il mio manuale più mi confondo.

Perchè scrivi 
malloc(sizeof(*matrice) * x * y)


e non 
malloc(sizeof(int) * x * y)

??

E poi:

Credo che i puntatori non siano molto diversi da degli array o meglio: gli array non sono molto diversi da dei puntatori. 
int array[n];
int *p;
p=array;


il "nome" dell'array corrisponde ad una locazione di memoria o meglio all'inizio del blocco di memoria che contiene in successione tutti gli indirizzi dei valori contenuti nell'array.

E fin qui ci sono. Il mio libro però non mi dice che posso fare 
int array[n];
int *p;
p=array;

p[5]=x; /* <-- questo */


mi dice semmai di fare 
int array[n];
int *p;
p=array;

p=p+5;
*p=x;


:pat:
aaa
31/10/10 14:57
TheKaneB
Postato originariamente da Giarados:

Postato originariamente da TheKaneB: 
int sizeX = 10;
int sizeY = 10;
int * matrice = malloc(sizeof(*matrice) * sizeX * sizeY);



// al posto di matrice[x][y] = 42;
matrice[x + y*sizeX] = 42;



Non ho capito bene, e più leggo il mio manuale più mi confondo.

Perchè scrivi 
malloc(sizeof(*matrice) * x * y)


e non 
malloc(sizeof(int) * x * y)

??

E poi:

Credo che i puntatori non siano molto diversi da degli array o meglio: gli array non sono molto diversi da dei puntatori. 
int array[n];
int *p;
p=array;


il "nome" dell'array corrisponde ad una locazione di memoria o meglio all'inizio del blocco di memoria che contiene in successione tutti gli indirizzi dei valori contenuti nell'array.

E fin qui ci sono. Il mio libro però non mi dice che posso fare 
int array[n];
int *p;
p=array;

p[5]=x; /* <-- questo */


mi dice semmai di fare 
int array[n];
int *p;
p=array;

p=p+5;
*p=x;


:pat:


evidentemente il tuo libro è scarso. Cambialo.
aaa
31/10/10 15:01
Giarados
Insomma: da ora sino a quando mi arriva il manuale Deitel & Deitel posso vedere i puntatori come degli array?
aaa
31/10/10 15:07
TheKaneB
Postato originariamente da Giarados:

Insomma: da ora sino a quando mi arriva il manuale Deitel & Deitel posso vedere i puntatori come degli array?


assolutamente si ;)
aaa
31/10/10 16:15
Giarados
Postato originariamente da TheKaneB:
e per accedervi poi, devi fare così: 
// al posto di matrice[x][y] = 42;
matrice[x + y*sizeX] = 42;



Mi viene spontaneo fare un'altra domanda. Io, sebbene ho seguito il tuo consiglio, devo fornire un'interfaccia per la classe che sto scrivendo che permetta l'accesso all'array come se fosse bidimensionale (sebbene sia implementato monodimensionalmente).

Quindi, sapendo che sto esaminando l'elemento n dell'array è giusto affermare che volendo restituire le coordinate attribuibili a tale elemento se esso fosse in un array bidimensionale allora dovrei utilizzare tali formule:

array[x + y*dimX] -> array[x + y*dimX] == array[n] --> n==x+y*dimX

x=n-y*dimX
y=(n-x)/dimX

o erro?

EDIT:

ops :rotfl: ho comunque bisogno di y e x...
Ultima modifica effettuata da Giarados 31/10/10 16:17
aaa
31/10/10 16:41
pierotofy
Postato originariamente da Il Totem:
Va de retro! Ti hanno fatto il lavaggio del cervello in Minnesota!


:nono:

Il lavaggio del cervello lo fanno in Italia quando dei professori reciclati da matematica si mettono ad insegnare informatica e decidono di tradurre impropriamente certi termini.
Il mio blog: piero.dev
31/10/10 17:13
TheKaneB
Postato originariamente da Giarados:

Postato originariamente da TheKaneB:
e per accedervi poi, devi fare così: 
// al posto di matrice[x][y] = 42;
matrice[x + y*sizeX] = 42;



Mi viene spontaneo fare un'altra domanda. Io, sebbene ho seguito il tuo consiglio, devo fornire un'interfaccia per la classe che sto scrivendo che permetta l'accesso all'array come se fosse bidimensionale (sebbene sia implementato monodimensionalmente).

Quindi, sapendo che sto esaminando l'elemento n dell'array è giusto affermare che volendo restituire le coordinate attribuibili a tale elemento se esso fosse in un array bidimensionale allora dovrei utilizzare tali formule:

array[x + y*dimX] -> array[x + y*dimX] == array[n] --> n==x+y*dimX

x=n-y*dimX
y=(n-x)/dimX

o erro?

EDIT:

ops :rotfl: ho comunque bisogno di y e x...


la formula inversa è semplice:
x = n % dimY;
y = n / dimY; // divisione intera

deriva dalla banale considerazione che, avendo A / B = quoziente + resto/B (che deriva a sua volta da A = B * quoziente + resto), posso ottenere resto = modulo_di(A / B) e quoziente = divisione_intera(A / B).
Ultima modifica effettuata da TheKaneB 31/10/10 17:15
aaa
31/10/10 20:07
Giarados
Grazie delle delucidazioni. Comunque sono costretto a ripiegare sulla soluzione di Piero dato che ho la necessità di definire un metodo per il ridimensionamento della matrice e non credo che sia fattibile avendo i dati disposti in maniera sequenziale a meno che non vada eliminando elementi periodicamente. Inoltre nel caso di un ingrandimento della matrice dovrei duplicare l'array per poi andarlo a ricopiare con 1 elemento in più ogni n elementi.

Naaa troppo complicato :)
Ultima modifica effettuata da Giarados 31/10/10 20:08
aaa