[C] Puntatore alla stessa struttura

[Negative_creep]

Ciao a tutti, vi espongo il mio problema: ho una matrice creata statisticamente in questo modo:

struct p {
int ID;
int riga;
int colonna;
char tipo[1];
struct p* su; /* Deve essere [Riga-1][colonna] */
struct p* giu; /* Deve essere [Riga+1][colonna] */
struct p* dx; /* Deve essere [Riga][colonna+1] */
struct p* sx; /* Deve essere [Riga][colonna-1] */

} matrice[riga][colonna];

Sostanzialmente ho bisogno di fare in modo che tramite un comando possa in qualche maniera accedere alle celle adiacenti della matrice, ad esempio se facessi:

matrice[2][2]->giu possa accedere a matrice[3][2]
matrice[2][2]->su possa accedere a matrice[1][2]
matrice[2][2]->sx possa accedere a matrice[2][1]
matrice[2][2]->dx possa accedere a matrice[2][3]

In modo tale che possa controllare il contenuto di ogni cella adiacente. Il problema è sapere se:

1) La dichiarazione struct p* su; va bene?
2) Che codice uso per muovermi? Ho sempre errori da parte del compilatore perchè sbaglio qualcosa a livello di aritmetica di puntatori nell'accesso alle varie celle.

Grazie in anticipo! :help:

[goldorak]

Scusa ma se allochi staticamente la matrice perche' ti servono i puntatori per spostarti da un elemento all'altro ? :confused:

[tuccio`]

come riempi quei 4 campi? (su, giu, dx, sx intendo)

[goldorak]

Ciao a tutti, vi espongo il mio problema: ho una matrice creata statisticamente in questo modo:

struct p {
int ID;
int riga;
int colonna;
char tipo[1];
struct p* su; /* Deve essere [Riga-1][colonna] */
struct p* giu; /* Deve essere [Riga+1][colonna] */
struct p* dx; /* Deve essere [Riga][colonna+1] */
struct p* sx; /* Deve essere [Riga][colonna-1] */

} matrice[riga][colonna];

Sostanzialmente ho bisogno di fare in modo che tramite un comando possa in qualche maniera accedere alle celle adiacenti della matrice, ad esempio se facessi:

matrice[2][2]->giu possa accedere a matrice[3][2]
matrice[2][2]->su possa accedere a matrice[1][2]
matrice[2][2]->sx possa accedere a matrice[2][1]
matrice[2][2]->dx possa accedere a matrice[2][3]

In modo tale che possa controllare il contenuto di ogni cella adiacente. Il problema è sapere se:

1) La dichiarazione struct p* su; va bene?
2) Che codice uso per muovermi? Ho sempre errori da parte del compilatore perchè sbaglio qualcosa a livello di aritmetica di puntatori nell'accesso alle varie celle.

Grazie in anticipo! :help:


La dichiarazione di struct p e' corretta.
Ogni nodo fa parte di una doppia lista concantenata, una nella direzione verticale (colonne), e l'altra in direzione orrizontale (righe).

Visto che hai scelto una struttura linkata, ovviamente per postarti nelle varie direzioni dovrai usare un algoritmo di visita su liste.
Se sai scorrere su una lista saprai scandire gli elementi della matrice.

Quello che invece non ha alcun senso e' l'allocazione statica.
Te lo dico perche' se allochi staticamente non servono i puntatori nei nodi.
Sono inutili, ridondanti in quanto ogni elemento in posizione x,y puo' essere
accessibile direttamente mediante matrice[x][y]. E ovviamente sono accessibili
anche i nodi adiacienti.

Infine per il modo in cui hai dichiarato la matrice scrivere

matrice[2][2]->giu
matrice[2][2]->su
matrice[2][2]->sx
matrice[2][2]->dx

e' sbagliato. Il modo corretto e'

matrice[2][2].giu (che e' di tipo struct p *)
matrice[2][2].su idem
matrice[2][2].sx idem
matrice[2][2].dx idem

Forse ho capito male, ma se quello che vuoi fare e' una matrice sparsa l'allocazione statica deve sparire.
Devi gestire la matrice come un insieme di liste doppiamente concatenate.
Una lista per ogni riga, ed una per ogni colonna.

[Negative_creep]

Innanzitutto grazie per le risposte, allora vi spiego subito quello che ho bisogno di fare:

ho creato una coda che vorrei riempire di record contenenti delle coordinate che puntano direttamente alla matrice, questo mi serve poichè ho bisogno di controllare il contenuto delle celle della matrice adiacenti alla cella dove ho inserito il dato.

Es. Inserisco un dato nella posizione matrice[2][4] allora inserisco nella coda
il seguente record:

[ ITEM 1 ] [SU] [GIU] [DX] [SX]

e se è il primo elemento che inserisco, tutti quei campi dovranno puntare alle celle adiacenti mostrandomi il contenuto in un dato momento. Essento il primo elemento che inserisco mostreranno "vuota" (tenendo conto di usare un esempio in cui non metto l'elemento vicino al bordo).
Ho bisogno che mettendo Item 2 sopra Item 1 avvenga la seguente cosa:

[ ITEM 2 ] [SU] [ITEM 1] [DX] [SX]
[ ITEM 1 ] [ITEM 2] [GIU] [DX] [SX]

quindi accedendo alla coda e dovendo piazzare Item 3, lui legga che Item 1 ha a disposizione GIU DX SX mentre ITEM 2 SU DX SX per poi scegliere (in base ad un mio calcolo) la miglior posizione dove inserirlo. E' necessario per me avere il riferimento degli elementi nella matrice[][] che ho creato statisticamente. Usando le liste concatenate avrei un grosso costo per gestire tutti i controlli mentre io ho bisogno semplicemente tramite coda accedere direttamente alla struttura matrice, ho pensato quindi che se facessi in modo tale da avere, prendendo l'esempio sopra,

[ITEM 1] nella coda è tradotto come ==> matrice[4][2]

se la struct matrice potesse accedere a sè stessa allora riuscirei:

[ITEM 1].SU ==> matrice[4][2].SU ==> matrice[3][2]

Non sò se sono riuscito a spiegarmi..

[Negative_creep]

UP! :rolleyes: