Newsgroup: it.comp.lang.c
Titolo: Per favore...mi spiegate il perchè ?

dato char *ptr;
dato ptr=malloc(30*sizeof(char));
perchè per attribuire a ptr  la stringa "stringa" devo utilizzare il
seguente codice:
ptr="stringa";
anzichè il seguente ?
*ptr="stringa";
il primo caso non lo dovrei utilizzare per attribuire a ptr un indirizzo di
memoria ?
Grazie

 ptr="stringa";
Guarda che questa approccio e' completamente sbagliato !
(cosi' come l'altro...)
Allora:quando esegui ptr=malloc(30*sizeof(char));
hai allocato uno spazio di memoria di 30 bytes (sufficiente quindi per
stringhe di 29 caratteri) e memorizzi in ptr un puntatore all'indirizzo
iniziale dello spazio allocato.
Quando vai ad eseguire l'istruzione ptr="stringa";
non stai "copiando" la stringa "stringa" in quei 30 bytes che hai 
allocato, ma semplicemente stai copiando nella variabile ptr il 
puntatore alla stringa costante "stringa" che il compilatore
infilera' da qualche parte nel codice.
Se vuoi mettere una stringa nello spazio allocato con
malloc devi usare strcpy:
strcpy(ptr,"stringa");
Ti puoi rendere facilmente conto del tuo errore con questo
esempio.
// alloco
ptr=malloc(30*sizeof(char));
// copio la stringa "aaaaaaaaaaaaa" nello
// spazio puntato da ptr
strcpy(ptr,"aaaaaaaaaaaaaaaaaa");
// copio il puntatore all'inizio della stringa
// costante "bbb" in ptr, perdendo quindi ogni
// possibile riferimento ai miei 30 bytes e alla
// stringa "aaaaaaaaaaaaa..."
ptr = "bbb";
// stampo la stringa puntata da ptr (cioe' "bbb")
// e il 10 carattere dall'inizio della stringa puntata:
// se stessi utilizzando i 30 bytes allocati sarebbe
// probabilmente una 'a'. Invece, con molta probabilita'
// sara' un carattere a caso (perche' e' quello che si
// trova in memoria un po' dopo la copia costante di "bbb"
// infilata' li' dal compilatore:
printf("<%s> <%c>\n",bbb,*(ptr+10));

 ptr="stringa";
* si mette per mettere su di una riga sola le due righe:
char *ptr;
ptr="stringa";
Invece, e qui capisci la differenza:
char *ptr;
ptr=malloc(30);
strcpy(ptr,"stringa");
if(ptr=="stringa)
In questo caso ti dira' sono diversi, infatti ptr punta ad una stringa che
contiene gli stessi caratteri della costante stringa ma che NON e' la
costante stringa e quindi il suo indirizzo sara' diverso.
La stessa cosa avviene con:
char ptr[]="stringa";
if(ptr=="stringa")
In questo caso, anche se puo' confondere, crei un array di caratteri che
contiene i caratteri {'s','t','r','i','n','g','a'}. In pratica ptr e'
l'indirizzo del primo elemento dell'array (&ptr[0]) e quindi ptr=="stringa"
restituira' false.
Tutto questo spero possa aiutarti a capire ed ampliare quello che ti ha
detto Giovanni Resta.
Concludo dicendo che per confrontare due stringhe, come avrai capito, == non
va bene! Meglio usare strcmp o simili!!!
Tommy

 contiene i caratteri {'s','t','r','i','n','g','a'}.
anche il '\0'.
Tommy

Non solo fa puntare ad una stringa, ma lascia allocata anche la memoria
senza più la possibilità di liberarla.
--------------------------------
Inviato via 
http://usenet.libero.it

Grazie a voi tutti. Sto imparando il C ma il manuale che uso a volte č non č
molto chiaro.
Ora ho capito.
Grazie

 senza più la possibilità di liberarla.
A che cosa ti riferisci? Ad usare malloc() poi ptr="stringa" ?!?
Certo! Se perdi l'indirizzo come puoi liberarla?!?
A meno che tu non faccia:
char *ptr, *tmp;
ptr=malloc(30);
tmp=ptr;
ptr="stringa";
free(tmp);
Per questo ho detto: "Se invece usi anche malloc, allochi della memoria che
poi non usi.".
Ad ogni modo quello che dici e' vero, l'ho dato per scontato, visto che se
non hai l'indirizzo non puoi liberarla, se salvi l'indirizzo puoi...
Tommy