windows - spørgsmål relateret til indekset af arrayer i c sprog

Indlæg af Hanne Mølgaard Plasc

Problem



hvorfor arrays første indeks starter med 0

Bedste reference


Fordi indekset faktisk betyder forskydningen fra pegeren. Forskydningen af ​​det første element er 0.


Opdater efter kommentar Nå, jeg prøver.


Lad os betragte en række byte med 10 elementer:


byte array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};


Overvej de hukommelsesceller, hvor dette array er placeret (lad os antage, at det starter fra adressen 0010h):


   0010  0011  0012  0013  0014  0015  0016  0017  0018  0019
  +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  10 |
  +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+


Vores variabel array peger på 0010h.


Offset for 1 (det første element) er 0 og dets faktiske adresse er 0010 + 0 (hvor 0010 er adressen til array og 0]] er forskydningen).


Forskydningen af ​​3 (det tredje element) er 2 fordi det er i den tredje celle, og cellestørrelsen er 1 (fordi vi har byte array). Det tredje elements faktiske adresse er 0010 + 2.


Kommer tilbage til vores programmeringssprog: array[0] betyder indholdet af hukommelsescellen, der har 0010 -adressen, array[1] betyder indholdet af hukommelsescellen med adressen 0010 + 1 ( det andet element) og så videre. *array i C refererer til det første element, *(array+1) - til det andet.

Andre referencer 1


Den samme grund til, at matematisk indstillede mennesker kalder i morgen 'en dag fra nu' i stedet for 'to dage fra nu'.

Andre referencer 2


Fordi peger aritmetik er lettere på den måde.


I C kan du behandle arrays som peger. På den måde, hvis du har dette array:


char a[50];
char *ptr = a;


Ved hjælp af pegeralithmetik kan du flytte pegeren ved at tilføje heltall til den på denne måde:


*(ptr + 0); // first character in the array
*(ptr + 1); // second character in the array
// so on, so forth

Andre referencer 3


Fordi element 0 er i en afstand på 0 fra begyndelsen af ​​arrayet. Det er det første element, men det er i position 0, ligesom den måde, at der ikke er år større end 100 i det første århundrede.

Andre referencer 4


Første og vigtigste: Fordi standard/din compiler siger det.
For det andet, på grund af pegeren aritmetiske. Hvis du har et array A, er A + 0 det første element, A + 1 sekund og så videre. Det er måden array er repræsenteret i hukommelsen.

Andre referencer 5


Det første indeks starter altid med nul på grund af den måde, hvorpå kompilatorerne bruger værdien af ​​et indeks til at beregne den faktiske adresse for et element i arrayet.


Overvej følgende eksempel.


void someFunction()
{
    int exampleArray[5] = {0, 1, 2, 3, 4};
}


'exampleArray', har brug for plads til at gemme 5 elementer, og hvert element vil kræve den nødvendige plads til at gemme en datatype 'int'. Afhængigt af platformen (16bit/32bit eller 64bit) og OS, kan størrelsen af ​​'int' datatypen være forskellig. Til vores diskussion kan vi sige, at størrelsen på 'int' er 4 bytes.


For at gemme ovenstående array i hukommelsen har vi brug for hukommelse for 5 heltal=5 * 4=20 byte.
Nu har hvert element i dette array en 'adresse'.


Lad os sige 'exampleArray' gemmes på adressen 100.
Derefter vil elementets adresse ved et indeks 'i' være 100 + (i * sizeof (int)). Så for ovenstående array,


Index 0, address = 100 + (0 * 4) = 100
Index 1, address = 100 + (1 * 4) = 104
Index 2, address = 100 + (2 * 4) = 108
Index 3, address = 100 + (3 * 4) = 112
and so on..


Sådan kompilerer generatoren kode for adgang til arrayindekser.
Så når vi skriver eksempelArray
   0010  0011  0012  0013  0014  0015  0016  0017  0018  0019
  +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |  9  |  10 |
  +-----+-----+-----+-----+-----+-----+-----+-----+-----+-----+
, skal computeren kunne beregne adressen til
element i indeks 2, for at kunne få adgang til dets hukommelsessted og dermed få adgang til dens værdi.
Så som pr. Ovenstående formel vil elementet på indekset '2' være 100 + (2 * 4)=108.


Da det første element i arrayet skal være på adresse 100, bliver dets indeks 0 for at beregne sin adresse på en simpel måde.