Perché il prossimo elemento di un array int memorizzato 4 byte dopo il precedente?

Question

Perché il prossimo elemento di un array int memorizzato 4 byte dopo il precedente?

#1 da (4 voti)
#2 da (2 voti)
#3 da (0 voti)

2

Ho questo piccolo codice:

int* array_int = new int[10];
    array_int[0] = 1;
    array_int[1] = 2;
    array_int[2] = 3;
    array_int[3] = 4;
    array_int[4] = 5;
    array_int[5] = 6;
    array_int[6] = 7;
    array_int[7] = 8;
    array_int[8] = 9;
    array_int[9] = 10;

    print(array_int);
    print(array_int + 1);
    print(array_int + 2);

L'output è questo:

Address: 009694B0
Value: 1
Address: 009694B4
Value: 2
Address: 009694B8
Value: 3

L'indirizzo è memorizzato dopo 4 byte dal precedente?

Quindi 009694B0 punta al primo byte di int 1? Quindi 009694B1 punta al secondo byte di int 1 e così via?

Ho pensato che 009694B0 punti a int 1 e 009694B1 a int 2 e così via.

c++

posta tuttomax 03.06.2016 - 12:39

fonte

3 risposte

4

Il tuo int è largo 32 bit, quindi ha bisogno di 4 byte di spazio di archiviazione. Il tipo di dati del puntatore è abbastanza intelligente da saperlo, quindi incrementare di 1 punti effettivamente 4 celle di memoria più in basso nella memoria, e questo è ciò che vedi nell'output.

risposta data 03.06.2016 - 12:42

fonte

0

I più piccoli dati indirizzabili sui computer moderni sono 1 byte. Gli indirizzi sequenziali sono per byte. Tuttavia, gli indirizzi possono avere un tipo. Nel tuo esempio, l'indirizzo ha tipo int * . Ogni int occupa 4 byte (sul tuo computer). Quindi l'incremento di un indirizzo di tipo int * incrementerà 4 byte.

Prova di nuovo l'esperimento con il tipo char * e poi di nuovo con il tipo long * per mostrare a te stesso come si incrementa l'indirizzo. Puoi anche utilizzare un puntatore void * e provare a incrementare quel puntatore.

risposta data 03.06.2016 - 17:42

fonte

Leggi altre domande sui tag c++

Devo restituire Iterable o Enumeration in Java Come creare stringhe multilinea per query SQL che sono leggibili, manutenibili e veloci?

score 2 · Accepted Answer

Le matrici devono lasciare abbastanza spazio tra ciascun indirizzo di offset per adattarsi a ciò che stanno memorizzando. Dato che hai una matrice di 4 byte int s, c'è una differenza di quattro byte tra l'indirizzo di ciascun elemento.

Diamo un'occhiata a ciò che un array di 4 byte int s assomiglia alla memoria (su un grandezza di byte -endiano sistema). Userò dei numeri diversi per i valori, quindi possiamo facilmente rintracciare quali byte appartengono a quali numeri interi. Ecco l'array che sto utilizzando:

int* array = new int[4]
array[0] = 0x1A1B1C1D
array[1] = 0x2A2B2C2D
array[2] = 0x3A3B3C3D
array[3] = 0x4A4B4C4D

Ed ecco come appare in memoria:

Address  Byte  Offset  Int
...
009694B0 (1A) -- 0  \
009694B1 (1B)  |     \ 0x1A1B1C1D
009694B2 (1C)  |     /
009694B3 (1D) /     /
009694B4 (2A) -- 1  \
009694B5 (2B)  |     \ 0x2A2B2C2D
009694B6 (2C)  |     /
009694B7 (2D) /     /
009694B8 (3A) -- 2  \
009694B9 (3B)  |     \ 0x3A3B3C3D
009694BA (3C)  |     /
009694BB (3D) /     /
009694BC (4A) -- 3  \
009694BD (4B)  |     \ 0x4A4B4C4D
009694BE (4C)  |     /
009694BF (4D) /     /
...

Ed ecco come apparirebbe se ogni valore fosse memorizzato nel byte successivo, invece del quarto byte:

Address  Byte  Offset  Int
...
009694B0 (1A) -- 0    0x1A2A3A4A
009694B1 (2A) -- 1    0x2A3A4A4B
009694B2 (3A) -- 2    0x3A4A4B4C
009694B3 (4A) -- 3    0x4A4B4C4D
009694B4 (4B)  |
009694B5 (4C)  |
009694B6 (4D) /
...

Questo non è esattamente ciò che abbiamo inserito. Solo l'ultimo numero che abbiamo assegnato, 0x4A4B4C4D è uscito indenne. Il resto è stato parzialmente sovrascritto dai numeri successivi.