Newsgroup: it.comp.lang.c
Titolo: Aiuto:Puntatori a puntatori

Ciao a tutti. Qualcuno saprebbe spiegarmi in maniera semplice a cosa
servono i puntatori a puntatori (normalmente indicati con **)?
Ho solamente capito che hanno a che fare con le strutture ma non capisco
bene come utilizzarli e sopratutto come passarli alle funzioni che ne
bisognano.
Se magari mi mandaste un esempio al mio indirizzo (ho una certa urgenza
per via di un esame alle porte) ve ne sarei molto grato.


I puntatori a puntatori possono servire sia da matrici che da una funzione
per modificare
il valore di un puntatore, come passeresti l'indirizzo di una variabile per
modificarla.
Per il secondo caso ecco un'esempio; una funzione free + "sicura)
void myfree(void** ptr)
{
    if((*ptr)==NULL)
        return;
    free(*ptr);
    *ptr=NULL;
}
Mentre per le matrici non fai altro che creare un array di array, ma
dinamicamente:
int **matrix=calloc(SIZE_X,sizeof(int*));
int c;
for(c=0;c<SIZE_X;c++)
    matrix[c]=calloc(SIZE_Y,sizeof(int));
e ovviamente devi fare l'inverso per deallocare.
Se vuoi fare una matrice tramite funzione devi usare un triplo ptr (es. int
***ptr)
ciao

 
Un puntatore a puntatore (talvolta chiamato doppio puntatore) serve a
darti l'indirizzo di un puntatore.
L'esempio piu' semplice di un doppio puntatore e' la matrice a due
dimensioni: <int pippo[2][3];>, dove pippo e' il nostro doppio
puntatore (cioe' un int**), pippo[0] e' il puntatore alla prima riga
(un int*), e pippo[1][2] e' l'intero (int) che sta nella posizione 2,3
della matrice (ti ricordo che in C il conteggio degli array parte da
zero, non da uno come il pascal).
Adesso facciamo finta che tu debba sommare il contenuto di una matrice
qualunque, e lo vuoi fare con una funzioncina, che ritorna il
risultato:
Userai il doppio puntatore, chiamato 'matrice', e supponiamo che
vengano fornite le dimensioni della matrice stessa, numRighe e
numColonne, due interi.
int SommaMatrice(int **matrice, int numRighe, int numColonne){
  int risultato = 0;
  int countRighe = 0;
  int countColonne = 0;
  while (countRighe < numRighe){
    // itero su tutte le righe
    while (countColonne < numColonne){
      // per ogni elemento della colonna sommo il valore dell'elemento
      risultato += matrice[countRighe][countColonne];
    }
  }
  return risultato;
}
Nell'esempio di pippo, la somma la ottieni chiamando
SommaMatrice(pippo, 2, 3);
Buona fortuna con l'esame ;)
Andrea
-----------------+-------------------------------- .~~~.  ))
 Andrea  Rimicci | abuse @@             (\__/)  .'     )  ))
-----------------+       aritaly. com   /o o  \/     .~
                                       {o_,    \    {
 Internet Abuse Dept. Executive officer  / ,  , )    \ .
 at AR Italy.                            `~  '-' \    } ))
                                        _(    (   )_.'
---------- OS/2 V5 "Phoenix" --------- '---..{____}

   }
Coff... coff.... piccola dimenticanza...


puntatore (cioe' un int**)
Attenzione, pippo non e' di tipo int** in questo caso, ma un
array-di-2-array-di-3-int.
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------
#exclude <windows.h>

 array-di-2-array-di-3-int. <snip>
Condivido,
ho 'sorvolato' sulla differenza, per produrre un esempio facile da
capire.
Formalmente, nell'esempio, e' piu' corretto:
int **pippo; , e poi allocare lo spazio per gli array.
Spero non me ne vogliate troppo :)


 capire.
Attenzione che queste affermazioni possono essere estremamente deleterie
per il principiante che, alla fine, non saprà distinguere un array da un
puntatore (succede spessissimo...). Meglio, in questi casi, essere
precisi.
EMG

int **pippo; , e poi allocare lo spazio per gli array.
Prima allocare lo spazio per i puntatori e poi allocare lo spazio
per gli array.
  int **pippo;
  pippo=malloc(2*sizeof(int *));
  pippo[0]=malloc(3*sizeof(int));
  pippo[1]=malloc(3*sizeof(int));
E in ogni caso la 'differenza' su cui hai sorvolato non era
proprio il cuore della domanda a cui volevi rispondere ?
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

bisognano.
Spero ti sia reso conto che vale esattamente tutto cio' che vale per
le altre variabili.
Il C si basa su un principio semplicissimo : KISS (Keep It Simple
Stupid) ;)
