Dubbio: Strcpy, versione con i vettori. Linguaggio C

[Giusyinthesky]

Questa funzione copia la stringa t sul vettore s. Io sono riuscita a capire la versione di strcpy con i puntatori ma non riesco a capire la versione con i vettori. Mi chiedo come è possibile che fornendo soltanto il puntatore al primo elemento del vettore (ovvero il nome del vettore stesso o "propriamente" il puntatore al primo elemento) poi la funzione riesce ad accedere a tutti gli altri elementi del vettore senza aver bisogno ancora dei puntatori. Non riesco a capire come opera il programma sotto questo aspetto...potete aiutarmi per piacere?


/*Copia t in s. Funzione con i vettori*/
#include

void strcpy(char s*,char t*)

main()
{
int i=0;
while((s=t)!='\0')
i++;

}

[cyd1]

quando definisci un array

 int a[]

a è del tutto identificabile col puntatore primo elemento dell'array ( con l'unica differenza che a è "read only" cioè non può essere un lvalue)

non so se tu abbia familiarità con l'aritmetica dei puntatori, ma se definisci un puntatore ad una cella:

int* p

il puntatore

p+1

sarà un puntatore alla cella (dello stesso tipo) adiacente. quindi ad esempio suppone di definire un array di due int:

 int arr[2]={1,2}

supponendo di avere una memoria con celle da un byte e suponendo che int occupi 4 bytes avrai così allocato 4 celle per il primo valore e 4 celle adiacenti per il secondo valore. supponendo che il primo valore occupi le celle con indirizzo (1 2 3 4) e il secondo (5 6 7 8) allora arr equivale ad un puntatore alla cella 1 e
poichè è definito int sa che deve leggere sizeof(int) celle successive (1,2,3,4) e trattarle come un intero.
allo stesso modo

arr[1][code] è come se fosse [code]*(arr+1)

cioè il valore contenuto dalla cella puntata dal puntatore che punta alla cella dopo quella di arr, cioè la 5

dunque se un array è completamente definito dal puntatore alla sua prima cella (infatti per riconoscere ad esempio quando una stringa finisce si usa convenzionalmente il carattere nullo '\0' proprio perchè la dimensione non rientr nella definizione dell'array)
allora per accedere agli elementi successivi basta incrementare il puntatore, cioè se
int *p = &array[0]
allora
*(p+1) = array[1]
*(p+2] = array[3]
eccetera

dunque una volta che una funzione ha un puntatore può accedere a tutte le celle adiacenti banalmente incrementando il puntatore.

[Giusyinthesky]

@cyd

grazie!..ora è un po' più chiaro..soltanto che il mio dubbio era proprio sulla versione di strcpy con i vettori; perchpè invece ho capito bene come si comporta la versione della stessa funzione con i puntatori...

ovvero...nel mio caso io passo soltanto i puntatori s e t ai primi elementi dei vettori..quindi permetto di conoscere l'indirizzo soltanto del primo elemento...probabilmente è sufficiente dare l'indirizzo del primo elemento del vettore perchè il computer possa interpretare le celle successive come appartenenti al vettore stesso? SENZA usare i puntatori?
E' per questo motivo che posso scrivere
s=t
senza problemi?
e senza dover ricorrere di nuovo al puntatore?

[Giusyinthesky]

"cyd":dunque una volta che una funzione ha un puntatore può accedere a tutte le celle adiacenti banalmente incrementando il puntatore.

e senza usare direttamente il puntatore? come in questo caso?

[cyd1]

beh il computer non riconosce nessun array o vettore, per lui sono celle e basta
quando definisci un array semplicemente allochi un certo numero di celle adiacenti.

cioè
se hai un puntatore

char* p 

se per il tuo computer questo è semplicemente una 'freccia' che punta ad una determinata area di memoria
quando cerchi di accedere al valore

*p

il computer accede alla cella a cui punta p, dato che p è di tipo char e char ha bisogno di un solo byte allora prenderà una sola cella a partire da p e ne legge il valore. se fosse stato int* p il pc avrebbe preso il valore di 4 celle a partire da p.

quando tu fai

*(p+1)

il pc va a leggere il valore della cella

p + sizeof(tipo del puntatore) 

e egge il valore di sizeof(tipo del puntatore) celle.

per il computer non esistono array, quando fai

array[3]

per lui vuol dire

*(array+3)

e accederà a tali celle.
semplicemente gli stai dicendo di accedere ad una determinata cella .

nel tuo caso
s identifica la i-esima cella dopo s
t la i-esima dopo t

è equivalente a fare

*(s+i)=*(t+i)

[Giusyinthesky]

quindi in pratica se ho un vettore int array[10] :

1 devo passare il nome del vettore (array) ad una funzione perchè in questo modo la funzione si sposta sulla prima cella dell'area di memoria contenente il vettore *

2 a questo punto all'interno della funzione posso usare le normali operazioni tra vettori perchè il computer ormai si è spostato su quella particolare area di memoria

*invece non posso passare array[0] (SENZA&) perchè in questo modo passerei soltanto una copia del contenuto del primo elemento di array e in questo caso, a differenza di ciò che accade per la 2, array[0] non viene usato come se fosse un puntatore..


esatto?

comunque grazie mille!!

[cyd1]

già, in reaktà se una funzione prende come parametro un puntatore e gli passi un array mi sa che due warning te li da. o fai una conversione implicita o gli passi l'indirizzo &arr[0]

non puoi passare array[0] perchè è char e il parametro dev'essere char*
se hai un array di puntatori chiaramente puoi