Newsgroup: it.comp.lang.c
Titolo: puntatori di puntatori e array dinamici ???

salve a tutti,
prendendo spunto dalla risposta del valido Marco Natoni a Enrico S.
sulla allocazione
dinamica di una matrice di caratteri, visto che non ne avevo abbastanza
di ingripparmi
con fork, socket FIFO e compagnia bella (sono un neofita del C), mi sono
ingrippato con
i puntatori di puntatori e con l'uso di questi con gli array
bidimensionali ...
ma veniamo al problema :
# include <stdio.h>
# include <stdlib.h>
int main (void)
{
int **var;
register int conta, conta1;
var = malloc (10 * sizeof (int));
for (conta = 0; conta < 10; conta ++)
	*(var + conta) = malloc (10 * sizeof (int));
for (conta = 0; conta < 10; conta ++)
	{
	for (conta1 = 0; conta1 < 10; conta1 ++)
		{
		**(var + conta1) = conta1 + conta;
		printf ("%d ", **(var + conta1));
		}
	*var += conta;
	}
free (var);
return 0;
}
ora veniamo alla domanda ... 
*var non e' un puntatore ad un'array di 10 int ?
e perche' quando sostituisco la riga
*var += conta;		con		*var ++; 
cioe' un'incremento del puntatore, che dovrebbe quindi puntare ai
successivi 10
elementi, mi da il famigerato Segmantion Fault (non so se l'ho scritto
bene, ma si 
capisce ....) ???
grazie anticipate a chiunque mi rispondera' ...
-- 
Antonio barbone ......
Outside of a dog, a book is man's best friend.
Inside of a dog, it's too dark to read.
		-- Groucho Marx

 wrote in message
| var = malloc(10 * sizeof(int));
alloca un array di 10 int.
ma var** e' un puntatore a puntatore ad int.
mi sembra che tu voglia allocare una "matrice" di interi 10x10.
la procedura e':
int **var;
int conta;
var = malloc(10*sizeof(int*)); /* alloca 10 int* */
for (conta = 0; conta < 10; ++conta){
    var[conta] = malloc(10*sizeof(int)); /* alloca 10 vettori di 10 interi
*/
}
puoi ora accedere ai valori con
var[riga][colonna] = valore;
per liberare la memoria:
for (conta = 0; conta < 10; ++conta){
    free(var[conta]); /* de-alloca i 10 vettori di 10 interi */
}
free(var); /* de-alloca 10 puntatori a int */
in senso opposto all'allocazione.

free (var);
No.
for ( conta = 0 ; conta < 10 ; conta++ ) 
    free( var[conta] ) ;
free( var ) ;
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------
#exclude <windows.h>

 #exclude <windows.h>
ciao ciao e grazie mille ....


 in senso opposto all'allocazione.
grazie mille .....


dealloca la memoria dei 10 puntatori ad int ?
Esatto.


Ciao,
Scusa se mi intrometto...ma ho un dubbio... il puntator di puntatori (lo so
che non si dice così ma è un sacco poetico ^_^) della matrice "var" lo
inizializzi come **var (con due asterischi) perchè punta ad un array di
puntatori che a loro volta puntano a 10 array anch'essi di puntatori, vero?
Grazie mille per eventuali info e spiegazioni
Enrico S.

puntatori che a loro volta puntano a 10 array anch'essi di puntatori, vero?
Non complichiamo le cose e ragioniamo in termini di semplici variabili
puntatori. Il fatto che non vi siano parentesi quadre nella
dichiarazione ti fa gia' capire che non puoi ragionare in termini di
"array".
var e' un puntatore a puntatore a intero, giusto ?
Questo significa che se alloco memoria per 10 elementi l'uno in coda
all'altro, ho allocato memoria per 10 puntatori a interi,
indirizzabili con var[0], var[1],... var[9].
Secondo passo :
Faccio spazio per 20 elementi ciascuno, cioe' predispongo lo spazio in
memoria per 20 interi l'uno in coda all'altro, per ognuno di questi
puntatori.
Ora var[3] punta al quarto puntatore a intero e var[3][2] e' il terzo
intero puntato dal quarto puntatore a intero.
Semplice no ? ;)
Ora, in base a questo semplice principio, puoi costruire il
semplicissimo programma qui di seguito, col quale spero di convincerti
a passare al C++ ;)
/* ----------------------- */
/* mxofmx.c                */
/* La matrice di matrici   */
/* ----------------------- */
/* (C)2000 Andrea Laforgia */
/* ----------------------- */
#include <stdio.h>
#include <stdlib.h>
void allocaUnaNuovaMatriceDiMatrici( int *****pmp_addr,
                                     int pmp_x, int pmp_y,
                                     int mtx_x, int mtx_y )
{
     int i, j, k ;
     *pmp_addr = malloc( pmp_y * sizeof( int*** ) ) ;
      for ( i = 0 ; i < pmp_y ; i++ )
     {
         (*pmp_addr)[i] = malloc( pmp_x * sizeof( int** ) ) ;
         for ( j = 0 ; j < pmp_x ; j++ )
         {
             (*pmp_addr)[i][j] = malloc( mtx_y * sizeof( int* ) ) ;
             for ( k = 0 ; k < mtx_y ; k++ )
                 (*pmp_addr)[i][j][k] = 
                            malloc( mtx_x * sizeof( int ) ) ;
         }
     }
}
void deallocaLaMatriceDiMatrici( int ****pmp,
                                 int pmp_x, int pmp_y,
                                 int mtx_y )
{
     int i, j, k ;
     for ( i = 0 ; i < pmp_y ; i++ )
     {
         for ( j = 0 ; j < pmp_x ; j++ )
         {
             for ( k = 0 ; k < mtx_y ; k++ )
                 free( pmp[i][j][k] ) ;
             free( pmp[i][j] ) ;
         }
         free( pmp[i] ) ;
     }
     free( pmp ) ;
}
void riempiLaMatrice( int ****pmp, int pmp_x, int pmp_y,
                                   int mtx_x, int mtx_y )
{
     int i, j, k, m ;
     for ( i = 0 ; i < pmp_y ; i++ )
         for ( j = 0 ; j < pmp_x ; j++ )
             for ( k = 0 ; k < mtx_y ; k++ )
                 for ( m = 0 ; m < mtx_x ; m++ )
                     pmp[i][j][k][m] = rand() % 50 ;
}
void scriviLaMatrice( int ****pmp, int pmp_x, int pmp_y,
                                   int mtx_x, int mtx_y )
{
     int i, j, k, m ;
     for ( i = 0 ; i < pmp_y ; i++ )
         for ( j = 0 ; j < pmp_x ; j++ )
         {
             printf( "matrice[%d][%d] : \n", i, j ) ;
             for ( k = 0 ; k < mtx_y ; k++ )
             {
                 for ( m = 0 ; m < mtx_x ; m++ )
                     printf( "%3d ", pmp[i][j][k][m] ) ;
                 printf( "\n" ) ;
             }
         }
}
int main()
{
    int ****TheMatrix ;
    allocaUnaNuovaMatriceDiMatrici( &TheMatrix, 6, 5, 4, 3 ) ;
    riempiLaMatrice( TheMatrix, 6, 5, 4, 3 ) ;
    scriviLaMatrice( TheMatrix, 6, 5, 4, 3 ) ;
    deallocaLaMatriceDiMatrici( TheMatrix, 6, 5, 3 ) ;
    return 0 ;


 void allocaUnaNuovaMatriceDiMatrici( int *****pmp_addr,
                                           ^^^^^
ROTFL! Sei un pazzo furioso ;-D
--
 Ciao, Bianco.
 Reply to 
luca....@tiscalinet.it

Prima di tutto grazie 1000 per l'estrema disponibilità. Se ho ben capito una
volta che ho inizializzato il tutto posso usare la matrice creata come se
fosse "statica" ad esempio se devo caricare stringhe al suo interno posso
scrivere direttamente
for (i=0;i<4;i++){
  printf("Nome numero %d", i+1);
  scanf("%s",vet[i]);}
Grazie 1000
Enrico S.

  scanf("%s",vet[i]);}
e' esatto (anche se al posto di scanf e' piu' saggio usare fgets), ma
l'accesso alla memoria e' totalmente diverso rispetto ad una matrice
allocata staticamente.
Mentre, infatti, in quest'ultimo caso i dati sono generalmente
presenti tutti nella stessa zona di memoria, nel caso di dati
"puntati", essi possono risiedere in zone della memoria anche molto
distanti tra loro e quindi non si puo' fare nessuna assunzione sulla
loro contiguita'.

Era esattamentre quello che volevo sapere! Per utilizzare fgets al posto di
qul è l'esatta sintassi (con riferimento al mio esempio precedente...)?
Ciao e ancora grazie per i tuoi consigli!
Enrico S.

qul è l'esatta sintassi (con riferimento al mio esempio precedente...)?
char buffer[50] ;
...
fgets( buffer, sizeof buffer, stdin ) ;

 fgets( buffer, sizeof buffer, stdin ) ;
In questo modo però non metto la stringa nella matrice o sbaglio?
Grazie 1000 (continuo a ringraziarti ti farò un regalo ^_^)
Enrico

Grazie 1000 (continuo a ringraziarti ti farò un regalo ^_^)
eh eh eh ;)