Newsgroup: it.comp.lang.c
Titolo: Re: accedere membro struttura stringa

 
char c[VAL+1];  tipo: array di caratteri con VAL+1 elementi (lunghezza 
max val)
"rossi" = puntatore a stringa costante (allocata nell'area base, se non 
sbaglio) di 5+1 caratteri.
ergo
current.c="rossi" equivale a Array=puntatore: operazione non possibile.
Utilizza le funzioni strcpy et simili per copiare una stringa in una array.
LP

Non è per essere polemico, ma hai l'orologio avanti di un giorno.
LP

 array.
scusate per l'ora.
Ti chiedo qualche chiarimento:
dire che rossi e' un puntatore a stringa costante significa dire che e' 
considerato come un puntatore a un tipo diverso da un puntatore ad una 
stringa generica?
se scrivo char a[10];
char *p;
definisco un array di caratteri e un puntatore a carattere.
ma se scrivo
p=a;
allora "a" non e' forse l'indirizzo del vettore di char che ho definito a 
cui faccio puntare p?
quindi, nel caso di origine, current.c non e' l'indirizzo del vettore di 
char current.c[VAL+1]?

 char current.c[VAL+1]?
Si ma prova ad immaginare le cose per come stanno veramente:
char a[10], sono 10 byte di memoria contigui ognuno dei quali occuperà
presumibilmente una lettera; char * p è un puntatore, occupa sempre e
comunque 4 byte (ia32) e conterrà un indirizzo ad un'area di memoria, che
presumibilmente conterrà delle lettere da interpretare come stringa fino
a un terminatore ('\0')
Ammesso che scrivendo 'a' da solo equivale a scrivere &a[0] ovvero si
identifica l'indirizzo del primo byte dei 10 allocati:
Fare p=a ha senso, perché nei 4 byte del puntatore p ci si andrà a
memorizzare l'indirizzo del primo elemento dell'array a. Fare a=p non ha
alcun senso.. i 4 byte di p dove dovrebbero essere memorizzati in a, che
per inciso potrebbe essere anche piu o meno di 10 byte.
Quello che tu vorresti ottenere da questo assegnamento è che per ogni
carattere disponibile nell'area di memoria puntata da p, vorresti una
copia su un successivo byte di a.. ovvero un ciclo sui caratteri puntati
da p finché non si incontra il terminatore di stringhe..
k=0;
while( *p != '\0' )
{
	a[k++] = *p;
	*p++;
}
a[k] = '\0';
che è proprio quello che fa strcpy(), o più in generale tutte le
funzioni str*() definite in string.h.
Ad esempio.. quando vorrai fare un confronto tra stringhe non potrai mai
usare l'espressione
if( p == a )... ma ricorerrai alla funzione strcmp()
Ad ogni modo tutta questa roba è di base.. dai un'occhiata sul web che è
pieno di spiegazioni di sicuro anche migliori..
Ciao
Mtc

 
quindi, e mi riallaccio alle tediose spiegazioni, current.c è un 
puntatore costante ad una area variabile e tu stai provando a spostarlo 
in un'altra posizione di memoria.
E' come dire
int var;
const int *p=&var; //puntatore costante ad area variabile
int var1;
p=&var1;
(qui ti darebbe errore, in quanto p non può cambiare, i contenuto 
dell'area puntata, ossia var, sì)
Ecco il motivo per cui non funziona.
Quello che funzionerebbe è una copia carattere per carattere (funzione 
strcpy) da una area sorgente (che può essere costante) ad una area 
destinazione (che *deve* essere variabile).
Il tuo codice corretto dovrebbe essere
strcpy(current.c,"rossi");
Spero di essere stato esaustivo e sufficientemente preciso nella 
spiegazione.
Ciao
LP

 cui faccio puntare p?
No, 'a' è un array. Punto. Però esiste una regola del linguaggio in base 
alla quale un'espressione che denota un array può in determinati contesti 
convertirsi implicitamente ("decadere") nel puntatore al suo primo 
elemento. Tali contesti sono quelle espressioni che richiedono un 
puntatore ma non un Lvalue.
In altre parole: se 'a' è un array, in certi constesti scrivere 'a' è 
equivalente a scrivere "&a[0]". Se quest'ultima espressione in un 
determinato contesto non può essere usata (come, ad es., a sinistra di un 
assegnamento), sei certo che in quel contesto 'a' non "decade" in un 
puntatore.
Max

 interpretate come puntatori costanti ad aree variabili.
E' una spiegazione un po' vaga e non del tutto corretta.
Un array decade nel puntatore al suo primo elemento in tutte le 
circostanze, meno tre specifiche:
1. quando il nome dell'array è argomento di sizeof;
2. quando il nome dell'array è argomento dell'operatore & 
(address-of);
3. quando si compie un'assegnazione mediante literal stringa;
Basta eseguire il seguente codice perché tutto diventi evidente:
#include <stdio.h>
int main()
{
     char *a="andrea", b[]="andrea";
     printf("sizeof(a)=%d ; sizeof(b)=%d\n", sizeof a, sizeof b);
     printf("&a=%p ; &a+1=%p ; &b=%p ; &b+1=%p\n", &a, &a+1, &b, 
&b+1);
     return 0;
}