Newsgroup: it.comp.lang.c
Titolo: Problema con i puntatori a carattere e funzioni

Ciao a tutti mi potreste aiutare a capire bene come si utilizzano i
puntatori a carattere? 
Non riesco proprio a capire perchè questo programma deve dare segmentation
fault...
#include <stdio.h>
void modifico(char *stringa);
int main(void)
{
        char *parola;  parola="CIAO";
        // inizializzando invece come fatto qui sotto non si blocca...
        //char parola[] = "Ciao";
        modifico(parola);
        return 0;
}
void modifico(char *stringa)
{
        for(;*stringa != '\0';stringa++) *stringa='X';
}
Non riesco a capire perchè non posso passare alla funzione un char *
mentre l'array si....
Vi ringrazio....penso sia una di quelle cose non facili di capire quando
si inizia...
Grazie!!!
--
Dany
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it


char* strPtrP = "stringa";
e
char strArr[] = "stringa";
hanno due comportamenti diversi.
Nel primo caso viene allocato lo spazio per una stringa da qualche
parte e l'indirizzo di stringa viene assegnato a strPtrP. Nel secondo
caso viene allocato spazio per un array lungo abbastanza da contenere
"stringa" (compreso il terminatore) e "stringa" viene copiato dentro
l'array (viene usato per inizializzare l'array).
Questo comporta che nel secondo caso e' lecito modificare il contenuto
dell'array, invece la modifica di quanto indirizzato da strPtrP e' un
"undefined behaviour" (gcc di default non consente la modifica di
"stringa", VC++ si).
</cite>
HTH
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 mentre l'array si....
Non dipende dal fatto che usi char * o puntatori o array.
Dipende solo dal fatto che la memoria dei literal-strings
(come ad esempio "CIAO") può non essere scrivibile.
int main(void) {
  char *parola1  = "CIAO"; /* parola1 punta ad un literal string */
  char parola2[] = "CIAO"; /* in parola2 e' copiato il literal string */
  char *parola3 = malloc(5);
  char parola4[5];
  strcpy(parola3, "CIAO"); /* in parola3 e' copiato il literal string */
  strcpy(parola4, "CIAO"); /* in parola4 e' copiato il literal string */
  modifico(parola4); /* sempre OK */
  modifico(parola3); /* sempre OK */
  modifico(parola2); /* sempre OK */
  modifico(parola1); /* puo' fallire */
  modifico("CIAO");  /* puo' fallire */
  return 0;
}

 }
Ciao


 C:>iao Angelo
Ciao


 cambia nel momento che istanzio della memora con malloc?
Lo standard dice che:
  - La memoria che corrisponde agli string literal
    può non essere modificabile (e se tenti di modificarla potrebbe
    succedere di tutto!).
  - Le altre memorie possono invece essere modificabili
    (per esempio la memoria ritornata da una malloc,
    o la memoria che corrispondente ad una dichiarazione di un array,
    etc...).
In soldoni i compilatori/linker sono liberi (non obbligati!) di porre
il contenuto dei literal-string in memoria read-only.
    Ovviamente alcuni compilatori lo fanno sempre.
    Alcuni non lo fanno mai.
    Altri ancora fanno in un modo o nell'altro
    a seconda di qualche specifico flag di compilazione.
Quindi se vuoi essere sempre sicuro
non tentare mai di modificare la memoria corrispondente
ad un literal-string.
- Dario

 strcpy(stringa,"Pippo");
Nel primo caso il compilatore potrebbe memorizzare la stringa
"Pippo" in un area di memoria read-only assieme alle altre costanti
del programma. Nel secondo caso non e' possibile che l'allocazione
di memoria venga fatta in un'area read-only, pertanto "Pippo" deve
essere per forza modificabile.
In ogni caso la modifica di una stringa costante e' un undefined
behavior, e andrebbe evitato in ogni caso.


 - Dario
Ciao,


 C:>iao Angelo
Ciao, 
