Newsgroup: it.comp.lang.c
Titolo: help puntatori a stringhe

Di nuovo salve.
Sto imparando il c da poco "da autodidatta" e vi chiedo scusa se vorrei un
altro chiarimento.
Sul mio libro trovo scritto che per usare una stringa posso dichiarare un
puntatore ad un carattere ed assegnare a questo una stringa ( il
compilatore assegnera' al puntatore l'indirizzo di memoria del primo
carattere).
Il bello e' che poi si specifica che si deve utilizzare questo puntatore
come una costante e non sono ammesse operazioni tipo a++ (con "a" nome
della stringa) ma solo operazioni del tipo *(a+1)
che è' uguale ad a[1], ma in barba a questo , negli esempi successivi , ci
sono accessi a determinati caratteri della stringa con *a++; cioe' viene
comunque effettuato un incremento.
Come devo regolarmi allora con questi puntatori ?
Risposte sul NG. Grazie.  
-- 
Saluti 
Antonio.
E-mail   
adel...@media.cesvitec.it
(spammatemi pure tanto questo e-mail lo do a "bau" ed "oink").

 scritto nell'articolo
<01be505c$75419c40$LocalHost@mc1360>...


Come devo regolarmi allora con questi puntatori ?
!!!! A T T E N Z I O N E !!!!
In C hai due modi per creare stringhe : quello che ti ho fatto vedere nel passo
precedente e quello che utilizza gli array di caratteri.
Pero' c'e' una grossa differenza che sfugge spesso a chi e' alle prime armi
(e a volte, per quello che ho potuto vedere, anche a chi si vanta di essere
esperto del linguaggio).
Dichiarare 
char *p
e dichiarare 
char p[20]
sono due cose enormemente diverse.
Nel primo caso p e' una variabile, nel secondo e' una costante (attenzione :
costante solo come indirizzo di memoria, non come dati contenibili).
In entrambi i casi essa contiene l'indirizzo del primo elemento dell'array, ma
nel primo caso questo indirizzo va innanzitutto assegnato (tramite funzioni di
allocazione) ed e' modificabile (tramite incrementi e decrementi), nel secondo
no.
Stai sicuro che gli incrementi che vedi negli esempi sono sempre effettuati su
puntatori a caratteri e non su array di caratteri.
Ricordati che la notazione indicizzata degli array transita verso i puntatori,
ma non accade la cosa inversa per quanto riguarda le operazioni aritmetiche di
incremento/decremento dei puntatori verso gli array.
Se immagini 'p' come una costante scrivere
*(p+2) significa scrivere qualcosa tipo *(50 + 2)
mentre scrivere
p++ significa scrivere 50 = 50 + 1 il che non ha senso...
Le operazioni di pre/post-incremento sono operazioni di assegnazione e per un
dato costante e' impossibile eseguire un'assegnazione.
Quindi, se p e' il nome di un array, le uniche operazioni aritmetiche consentite
sono quelle a base fissa ed indice variabile del tipo
*(p + i) o *(i + p)
con i variabile intera.
In sostanza ricordati che il nome di un array di caratteri e' un puntatore
costante, un puntatore a carattere e' una variabile.
Andrea, mica uno qualunque...
--------------------------------------------------
"Ho cambiato signature, si vede ?" 
--
Posted from 
itaca.ulysse.it
 [195.223.254.1]
via Mailgate.ORG Server - 
http://www.mailgate.org

 Come devo regolarmi allora con questi puntatori ?
Se il puntatore è dichiarato semplicemente
char *a;
allora puoi effettuare tutti gli incrementi che vuoi. Se invece è
dichiarato
char * const a;
allora non si potrebbe incrementare in quanto puntatore costante (ma il
mio DJGPP in modalità C dà in questo caso solo un warning mentre in
modalità C++ dà un errore). Per completezza
const char *a;
darebbe invece la possibilità di spostare il puntatore ma non di
alterare l'oggetto puntato. Naturalmente vale anche
const char * const a;
che racchiude entrambi i divieti.
EMG

Come devo regolarmi allora con questi puntatori ?
Se il puntatore e` un puntatore non costante, allora puoi
modificarlo; se e` costante, allora non puoi.  Costante e`
un puntatore dichiarato tale, o quello che proviene da una
espressione (e` rvalue ma non lvalue), come ad esempio:
    char* pippo = "pero";    /* ok */
    ++pippo;    /* pure OK, pippo punta alla 'e' */
    ++(pippo+2);    /* NON ok, ++ di un'espressione! */
    char pero='e';
    pippo=&pero;    /* OK */
    ++pippo;           /* pure OK */
    ++(&pero);        /* NON ok, ++ di un'espressione! */
    char* const peppo = "Palo";    /* OK */
    ++peppo;           /* NON ok, ++ di una const! */
Le regole che determinano quali puntatori sono constanti,
e cosa cio` significa in termini di non-modificabilita`, sono
d'altronde del tutto analoghe a quelle che determinano
le stesse cose per gli interi, i double, ecc ecc.
Alex