Newsgroup: it.comp.lang.c
Titolo: Pile, code e doppie indirezioni...

Ciao a tutti,
sto preparando l'esame di c per metà settembre e sono arrivato a programmare
code e pile.
Se vi è possibile gradirei sapere se con l'istruzione:
        &( (*rowPtr)->colPtr )
ottengo l'indirizzo di colPtr.
Utilizzo due struct così definite:
struct colonne {
        int value;
        struct colonne *nextPtr;
        };
typedef struct colonne COLUMNS;
typedef COLUMNS *COLUMNS_PTR;
struct righe {
        COLUMNS_PTR colPtr;
        struct righe *nextPtr;
        };
typedef struct righe ROWS;
typedef ROWS *ROWS_PTR;
Il mio intento è quello di creare una pila di "righe" e all'interno di ogni
elemento della riga creare una coda di "colonne", per poter imagazzinare e
successivamente ruotare una matrice quadrata. Concettualmente non è
difficile realizzare una cosa simile ma quando devo andare a prendere
l'indirizzo di colPtr cominciano i problemi e si vengono a creare dei
riferimenti circolari (tra gli elementi delle colonne) che mi mandano in
loop infinito le routine di stampa.
se qualche anima pia avesse voglia di schiarirmi le idee...
ps. sto studiando sul deitel & deitel e un esempio simile viene fatto sugli
alberi binari...a loro funziona...e a me no... :-)
ps2. posso anche postare l'intero sorgente, se volete, ma sono più di 300
righe...
Grazie a tutti!
Ciao May!

righe...
non riesco a trovare l'esempio di cui parli. Se vuoi posta il
sorgente, ma se è lungo cerca di limitarti alle parti più
significative, puoi essere aiutato più facilmente.
Buon lavoro
-- 
Ciao, Giuseppe

 significative, puoi essere aiutato più facilmente.
l'esempio è a pg. 437 quando richiama in modo ricorsivo la funzione
insertNode.
ti ringrazio molto dell'interessamento anche perchè ho avuto da te conferma
dell'errore che avevo fatto (maledetti doppi puntatori...avevo sudato 7
camice per capire quelli semplici e ora scopro l'esistenza di quelli
doppi...ARGHH!!!)
Buon Lavoro anche a te!
Yusef

insertNode.
 [snip]
esatto, il problema è proprio l'inserimento della radice dell'albero
(o, equivalentemente, del primo elemento di una lista). Riprendiamo il
nostro esempio: abbiamo la procedura
void insertNode(TREENODEPTR treePtr, int value);
se dovessimo fare treePtr = malloc(sizeof(TREENODE)), quando il
controllo torna alla funzione chiamante (nel nostro caso il main) la
variabile non risulterebbe modificata. Quindi è necessario simulare
una chiamata per riferimento, cosa che può essere fatta passando
l'indirizzo della variabile; poiche treePtr è già un puntatore, viene
passato un puntatore a puntatore.
Inoltre, considera che se non ci fosse la necessità di inserire la
radice dell'albero, ma solo gli altri nodi, sarebbe superfluo passare
il puntatore a puntatore, perché le modifiche ai membri di una
struttura fatte con l'operatore 'puntatore a struttura' ->, ad esempio
treePtr->leftPtr = malloc(sizeof(TREENODE)), sono visibili alla
funzione chiamante.
A questo punto, se decido di usare una chiamata per riferimento
simulata, il prototipo di insertNode diventa
void insertNode(TREENODEPTR *treePtr, int value);
e per invocare ricorsivamente insertNode su uno dei due membri di una
foglia devo scrivere
insertNode(&((*treePtr)->leftPtr), value);
come fa il D&D.
-- 
Ciao, Giuseppe

ti ringrazio sia per il notevole contributo che mi hai dato nel capire
quest'aspetto dei puntatori (e ti garantisco che mi avevano confuso le idee
non di poco...) sia per tutto il tempo che hai passato per starmi dietro
(anche il solo rileggerti tutto l'esempio del D&D è cosa non da poco...).
a questo punto se prendo un bel voto all'esame ti sono debitore!!!!!!!!
Ciao Yusef!
--------------------------------
Inviato via 
http://usenet.libero.it