Newsgroup: it.comp.lang.c
Titolo: modificare il valore di un puntatore a char in una funzione

Ragazzi.. scusatemi un consiglio.. ho necessità di modificare il contenuto
di un puntatore a char.. pensavo di saperlo. fare ma mi rendo conto che al
ritorno della funzione.. mi riprinta il vecchio valore.. come se non fosse
successo niente..
dove sbaglio?
Grazie ecco il codice:
char valore[1024] = "aaa";
printf("\nTorno1: %s", valore);
prova("Var_tre", valore);
printf("\nTorno1: %s", valore);
void prova(char NomeVar[], char Valore[])
{
	printf("Sto cercando: %s", NomeVar);
	char field[256] = "uuu\0";
 
	Valore = (char *) realloc(NULL, strlen(field)); 
	strcpy(Valore, field);
	printf("\nAAA: %s\n", Valore);
}
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it


dentro la funzione puoi modificare i valori a cui punta il puntatore ma non
il puntatore stesso. Per cui
Valore = realloc(...);
una volta che esci dalla funzione Valore non viene modificato.
Per modificare l'indirizzo del puntatore devi accettare come argomento un
puntatore a puntatore :
void prova(char NomeVar[], char **Valore) {
...
}

 	char field[256] = "uuu";
sbagli anche qui^^^^^^^^^^^^^^^^^^^^
In "C" non e' ammesso dichiarare variabili dopo il codice
In "C" le variabili vengono passate per valore, anche i puntatori.
Con il tuo codice assegni al parametro "Valore" il valore
dell'indirizzo dell'array "valore".
Questo e' locale alla funzione "prova" e viene perso al ritorno da
questa.
Se vuoi modificare il valore di un puntatore fuori dalla funzione dove
questa modifica avviene, devi passare l'indirizzo della variabile che
contiene quell'indirizzo.
In questo caso la cosa comunque non e' fattibile in quanto "valore"
e' un array e non un puntatore.
HTH
C:\>iao Angelo


 In "C" non e' ammesso dichiarare variabili dopo il codice
Anche con il nuovo standard?

 Anche con il nuovo standard?
No, con quello no. Il problema e' trovare compilatori che aderiscono
all'ultimo standard... Cerdo siano ancora pochini. :-)


 }
ok non ho fatto come hai detto te, ma funziona.. ho fatto cosi':
//Valore = (char *) realloc(NULL, strlen(field));
strcpy(Valore, field);
In poche parole ho commentato la realloc.. perchè mi ero accorto che se
facevo una printf (prima di fare una realloc) avevo lo stesso indirizzo di
memoria.
Adesso vorrei sapere cosa mi conviene fare.. se questa è una soluzione
sporca ecc.. (nel caso non mi convenga mantenere questa soluzione mi
potreste fare un esempio concreto o redirigermi verso un tutorial che mi
spieghi i doppi puntatori e i passaggi alle funzioni?)
Cmq questa soluzione funge...
Ah.. utilizzo Visual C++.net (nuovo standard)  quindi posso fare
dichiarazioni dopo il codice.
grazie a tutti



Innanzitutto realloc(NULL, ...) equvale a malloc per cui utilizza malloc in
questo caso.
Visto che la memoria allorcata per field è minore di quella allocata per
Valore la soluzione tua va bene,cioè strcpy non da errore.
Ma non ho capito tutto quel casino che hai fato realloc compresa...a cosa
serviva?

 serviva?
Bhè, devo leggere un file di configurazione e predermi il campo
interessato.
Ciao



Beh non è fortuna. Sei stato tu ad allocare memoria sufficiente nella
dichiarazione:
char valore[1024] = "aaa";
..
char field[256] = "uuu\0";
Quindi 1024 byte per valore e 256 per field. Anche qui non mi ricordo se la
assegnzione che hai fatto riduce la quantità di memoeria disponibile per
Valore da 1024 a 4 byte.
Stessa cosa vale per field, dove fra l'altro non ho capito perchè metti il
carattere \0 nella stringa visto che viene messo dal compilatore
automaticamente.
Se facevi
char field[256] = {'u', 'u', 'u', '\0'};
allora sì che andava messo.
Se realloc non trova spazio di memoria contiguo sufficiente allroa cambia
indirizzo  al puntatore. Quindi devi tenere traccia del nuovo indirizzo con
un puntatore a puntatore come argomento.
Altra cosa Valore è stato dichiarato come array...l'indirizzo dell'array è
costante e non puoi modificarlo. Quindi usa un puntatore e non un array
statico.
 Altro mio dubbio...quando la realloc cambia l'indirizzo del puntatore cosa
succede al vecchio spazio di memoria? va rilasciato dal programmatore o se
ne occupa la realloc?

 piccolo lo rialloco cosi, giusto?
ATTENZIONE ATTENZIONE !!
fare
Valore = (char *) realloc(Valore,strlen(field) );
oppure Valore=(char *) malloc(strlen(field));
e poi
strcpy(Valore,field);
e' SBAGLIATO !
se field e' la stringa "abc" allora strlen(field)
ritorna 3 (la lunghezza di "abc") ma in memoria
la stringa "abc" occupa 4 (non 3) bytes, perche'
c'e' il carattere nullo che termina la stringa, che
non viene contato da strlen, (ma viene ovviamente
copiato da strcpy).
Quindi la realloc o la malloc con argomento
strlen(field) alloca 1 byte meno del necessario,
e quando vai a fare la strcpy
vai a scrivere un byte a zero oltre lo spazio
legittimamente allocato.
Se sei fortunato (grazie ai buchi dell'allineamento,
per esempio) non succede nulla, ma....
ciao,
g.

 memoria? oppure devo lavorare con i doppi puntatori?
ritorni dalla funzione il nuovo pointer e lo riassegni
ciao
 sbirish

  sbirish
Scusami (sono un po incapace con i puntatori)
Grazie


 ha scritto nel messaggio
news:b2r504$hjn$1...@news.newsland.it...

Ascolta č meglio se riposti il codice modificato e ci dici quali sono i
nuovi dubbi perchč qua tra array statici anzichč dinamici ed errori di
allocazione non si capisce piů molto.

 dichiarazioni dopo il codice.
Sicuro, sicuro? Non e' che stai usando il compilatore C++ senza saperlo?
Fai una prova. Incece di scrivere
Valore = (char *) realloc(NULL, strlen(field));
cosa che in "C" e' sconsigliata (e' un cast inutile), scrivi
Valore = realloc(NULL, strlen(field));
Se continua a compilarti, tanto di cappello a mamma MS che si e' adeguata
allo standard prima degli altri.
Se (come sospetto) non ti funziona, ti suggerisco di riscrivere la
dichiatazione delle variabili PRIMA delle chiamate di funzione (e di
dare l'estensione ".c" ai file cosi' usi il compilatore "C").
C:\>iao Angelo


 Valore = (char *) realloc(Valore,strlen(field) );
Chiamata da evitare. Se realloc() fallisce Valore diventa NULL e perdi
i dati precedentemente puntati da Valore.
Meglio passare per una variabile d'appoggio.
C:\>iao Angelo
