Newsgroup: it.comp.lang.c
Titolo: PerchÃ¨ 'sto FOR non va?

Giocando con gli array a caratteri , mi sono imbattuto in questo
problema:
Come faccio ad associare diverse stringhe agli elementi di un array di
puntatori a char?
Questo è il codice che ho provato, ma non sono venuto a capo di
nulla.....
	#define ARR_LEN 10
	char* buf;
	char* pcharr[ARR_LEN];
//NESSUNO dei tre cicli for funzionano (vengono compilati, ma mandano in
//segmentation fault il programma)
	for(i=0;i<ARR_LEN;i++)
	{
		sprintf(buf,"stringa numero %d",i);
		strcpy(pcharr[i],buf);
	}
	for(i=0;i<ARR_LEN;i++)
	{
		sprintf(pcharr[i],"stringa numero %d",i);
	}
	for(i=1;i<ARR_LEN;i++)
	{
		pcharr[i]=malloc(20);
		sprintf(pcharr[i],"stringa numero %d",i);
	}
//QUESTA è l' unica che funziona, ma pcharr[i]="stringa numero 9" per
ogni i!!!
	for(i=1;i<ARR_LEN;i++)
	{
		sprintf(buf,"stringa numero %d",i);
		pcharr[i]=buf;
	}
Da notare che da un ciclo del genere:
	for(i=1;i<ARR_LEN;i++)
	{
		pccharr[i]="\0";
		printf("indirizzo di pcharr[%d]: %X, punta a:
%X\n",&buf,i,&pcharr[i],pcharr[i]);
	}
sembra che tutti i pcharr[i] puntino alla stessa locazione di memoria
per ogni i! Perchè?
Se invece non inizializzo con pccharr[i]="\0"; tutti gli elementi, ogni
pccharr[i] punta ad una locazione diversa
Se fuori dal ciclo for eseguo istruzioni del tipo
pccharr[1]="ciccio";pccharr[2]="molecola";, allora pccharr[1] e
pccharr[2] puntano a locazioni differenti. Perchè all'interno di un
ciclo for, questo non avviene?
Grazie,
Mat

il problema è che non allochi la memoria
tu scrivendo char*
pcharr[ARR_LEN];
hai dichiarato un array di puntatori ma non hai allocato
la memoria per ogni elemento.
dovrai fare una malloc per allocarla
--------------------------------
Inviato via 
http://usenet.iol.it
 

 ha scritto nel messaggio
news:3CBBDD41...@dei.unipd.it...

----------------------------------------------------------------------
prova con questo esempio a fare gli adattamenti tuoi desiderati:
#include <stdio.h>
#include<stdlib.h>
#include<string.h>
#define ARR_LEN 10
#define L_MAX 81
int main ()
{
int i;
char car,buf[L_MAX];
char* pcharr[ARR_LEN];
printf("\ninserire %d stringhe \n",ARR_LEN);
 for(i=0;i<ARR_LEN;i++)
 {
 printf("stringa %d ",i+1);
 fgets(buf,L_MAX,stdin);
 pcharr[i]=malloc((strlen(buf)+1)*sizeof(char));
 strcpy(pcharr[i],buf);
 }
printf("\nstringhe puntate dall'array di puntatori a carattere\n");
for(i=0;i<ARR_LEN;i++)
 printf("%d) %s ",i+1,pcharr[i]);
scanf("\n%c", &car);
return (0);
}

 per ogni i! Perchè?
Guarda che la printf è sbagliata: stampi 3 valori ma gli passi 4 argomenti
(&buf non ci dovrebbe essere). I puntatori poi si stampano con %p.
In ogni caso, con pccharr[i]="\0" assegni a pccharr[i] l'indirizzo della
stringa "\0". Niente di strano che puntino tutti allo stessa locazione.
Cerco di chiarirti qualcosa sui puntatori con un esempio.
Se definisci la variabile:
    char *p;
questa non fa altro che riservare un po' di spazio in memoria (la quantità
dipende dal sistema operativo, 4 byte per win32). Supponiamo che questo
spazio venga riservato a partire dalla locazione di memoria 1000, allora le
locazioni 1000, 1001, 1002 e 1003 saranno utilizzate da p, ma non contengono
nessun valore significativo.
con l'istruzione:
    p = "prova";
la stringa "prova" si trova da qualche parte della memoria (ad esempio
all'indirizzo 2000);  si assegna questo indirizzo a p. In questo modo hai:
    &p = 1000            // l'indirizzo di p
    p = 2000               // il valore di p
    *p = 'p'                 // p punta al primo carattere della stringa
"prova"
In altre parole, all'indirizzo 1000 trovi il valore 2000, all'indirizzo 2000
trovi la stringa.
Fai attenzione che non puoi usare l'istruzione: strcpy(p, "altra stringa")
perché questa stringa verrà copiata all'indirizzo puntato da p. Inizialmente
p non puntava a niente, quindi dove verrà copiata la stringa non si sa. Dopo
l'istruzione p = "prova", la nuova stringa si sovrapporrà a "prova", ma
essendo più lunga andrà ad occupare altro spazio che non le è stato
assegnato, con effetti imprevedibili (a parte il fatto che "prova" è una
stringa costante e non verrà permessa una sua modifica).
Con una successiva istruzione:
    p = malloc(20);
viene riservato uno spazio di 20 byte in qualche parte della memoria, ad
esempio all'indirizzo 3000. Il valore di p viene cambiato con il valore che
gli viene riportato dalla funzione malloc (cioè 3000). Ora puoi anche usare
l'istruzione strcpy(p, "altra stringa"), perché "altra stringa" verrà
copiata nel nuovo spazio assegnato.
Maurizio.

 Maurizio.
Grazie per le delucidazioni....
Quindi, per poter memorizzare stringhe variabili in lunghezza durante l'
esecuzione del programma, il modo + pulito è quello di usare char* con
seguente malloc() realloc() e free(), ho capito bene?

 puntatori in C non sono molto ortodossi...)
Se e' necessario un cast di solito si sta facendo una porcheria.
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG