Cambia il puntatore a un array per ottenere un elemento array specifico

Question

Comprendo il significato generale di puntatori e riferimenti (o almeno penso di sì), capisco anche che quando uso nuovo sto allocando dinamicamente la memoria.

La mia domanda è la seguente:

Se dovessi usare cout << &p, visualizzerebbe il " posizione della memoria virtuale " di p. Esiste un modo per manipolare questa & Quot; posizione della memoria virtuale? & Quot;

Ad esempio, il codice seguente mostra un array di int s.

Se volessi mostrare il valore di p[1] e sapessi il " posizione della memoria virtuale " di &p + 1, posso in qualche modo fare " cout << *p " e ottenere il valore di <=> con <=>, che indicherà ora il secondo elemento dell'array?

int *p;
p = new int[3];

p[0] = 13;
p[1] = 54;
p[2] = 42;

Answer 1

Certo, puoi manipolare il puntatore per accedere ai diversi elementi dell'array, ma dovrai manipolare il contenuto del puntatore (cioè l'indirizzo di ciò che p punta), piuttosto che l'indirizzo del puntatore stesso .

int *p = new int[3];
p[0] = 13;
p[1] = 54;
p[2] = 42;

cout << *p << ' ' << *(p+1) << ' ' << *(p+2);

Ogni aggiunta (o sottrazione) indica l'elemento (precedente) successivo nella matrice. Se p indica una variabile a 4 byte (ad es. int su PC a 32 bit tipici) all'indirizzo dire 12345, p + 1 punterà a 12349 e non a 12346. Nota che si desidera modificare il valore di cosa contiene p prima di dereferenziarlo per accedere a ciò a cui punta.

Answer 2

Non proprio. &p è l'indirizzo del puntatore p . &p+1 farà riferimento a un indirizzo che è uno int* più avanti. Quello che vuoi fare è

p=p+1; /* or ++p or p++ */

Ora quando lo fai

cout << *p;

Otterrai 54. La differenza è che <=> contiene l'indirizzo dell'inizio della matrice di ints , mentre <=> è l'indirizzo di p . Per spostare un oggetto lungo, devi puntare ulteriormente nella int array , non oltre il tuo stack, che è dove <=> vive.

Se avessi solo <=>, dovrai fare quanto segue:

int **q = &p; /* q now points to p */
*q = *q+1;
cout << *p;

Questo produrrà anche 54 se non sbaglio.

Answer 3

È passato un po 'di tempo (molti anni) da quando ho lavorato con i puntatori ma so che se p sta puntando all'inizio dell'array (cioè p [0]) e lo hai incrementato (cioè p ++) allora p sarà ora indicando p [1].

Penso che devi de-referenziare p per arrivare al valore. Dereferisci un puntatore mettendo un * davanti.

Quindi * p = 33 con modifica p [0] in 33.

Suppongo che per ottenere il secondo elemento useresti * (p + 1), quindi la sintassi di cui avresti bisogno sarebbe:

cout << *(p+1)

o

cout << *(++p)

Answer 4

Mi piace fare questo:

&p[1]

Per me sembra più ordinato.

Answer 5

Pensa a " tipi di puntatore " in C e C ++ che stabilisce una riga di celle molto lunga e logica sovrapposta ai byte nello spazio di memoria della CPU, a partire dal byte 0. La larghezza di ogni cella, in byte, dipende da il " digitare " del puntatore. Ogni tipo di puntatore stabilisce una riga con diverse larghezze di cella. Un puntatore "int *" stabilisce una riga di celle a 4 byte, poiché la larghezza di archiviazione di un int è di 4 byte. A "double *" stabilisce una riga di 8 byte per cella; un "struct foo *" puntatore indica una riga con ogni cella della larghezza di un singolo "struct foo", qualunque essa sia. Il & Quot; indirizzo & Quot; di qualsiasi " cosa " è l'offset di byte, a partire da 0, della cella nella riga che contiene il " cosa " ;.

L'aritmetica del puntatore si basa sulle celle della riga, non sui byte . " *(p+10) " è un riferimento alla decima cella " p " ;, in cui la dimensione della cella è determinata dal tipo di p. Se il tipo di & Quot; p & Quot; è " int " ;, l'indirizzo di " p + 10 " è 40 byte oltre p; se p è un puntatore a una struttura lunga 1000 byte, " p + 10 " è di 10.000 byte oltre p. (Nota che il compilatore può scegliere una dimensione ottimale per una struttura che potrebbe essere più grande di quello che pensi; questo è dovuto a & Quot; padding & Quot; e & Quot; allineamento " La struttura di 1000 byte discussa potrebbe effettivamente richiedere 1024 byte per cella, ad esempio, quindi " p + 10 " sarebbe effettivamente 10.240 byte oltre p.)