Kuinka määrittää taulukon pituus C-kielellä

C-kielessä voit määrittää tau­lu­koi­den pituuden luo­tet­ta­vas­ti useilla eri me­ne­tel­mil­lä. Näin tau­lu­koi­den hallinta on helpompaa ja ne voidaan mukauttaa koon muu­tok­siin dy­naa­mi­ses­ti.

Mikä on taulukon pituus C-kielessä ja mitä me­ne­tel­miä sen mit­taa­mi­seen on olemassa?

Kun mitataan taulukon pituutta C-kielellä, mitataan taulukon si­säl­tä­mien ele­ment­tien lu­ku­mää­rää. Tämä tieto on rat­kai­se­van tärkeää, kun halutaan käyttää taulukon yk­sit­täi­siä ele­ment­te­jä, käydä taulukko läpi tai suorittaa ma­ni­pu­loin­te­ja. Kun taulukko mää­ri­tel­lään C-kielellä, taulukon ele­ment­tien muisti varataan RAM-muistiin peräkkäin (eli jär­jes­tyk­ses­sä ilman aukkoja). C-kielessä ei ole si­sään­ra­ken­net­tua funktiota taulukon pituuden mää­rit­tä­mi­seen, joten se on mää­ri­tet­tä­vä ma­nu­aa­li­ses­ti.

Ylei­sim­mät me­ne­tel­mät ovat:

• sizeof()
• Pointer-arit­me­tiik­ka
• Silmukat

sizeof()

sizeof() ope­raat­to­ri C-kielessä. Se määrittää da­ta­tyy­pin tai muuttujan koon tavuina kään­nös­ajon aikana. Ope­raat­to­rin sizeof pa­lau­tus­tyyp­pi on size_t, unsigned integer -tyyppi, joka edustaa kokoa tavuina. C-kielessä voit myös käyttää sizeof() taulukon pituuden las­ke­mi­seen.

Syntaksi

Jotta voit määrittää taulukon ele­ment­tien lu­ku­mää­rän, sinun on jaettava taulukon ko­ko­nais­ko­ko yk­sit­täi­sen elementin koolla.

data_type arrayLength = sizeof(array_name) / sizeof(array_name[index]);

• data_type: Tämä on tie­to­tyyp­pi, johon taulukon pituus tal­len­ne­taan.
• array_name: Määrittää taulukon nimen.
• sizeof(array_name): Tämä lauseke palauttaa taulukon ko­ko­nais­koon tavuina.
• sizeof(array_name[index]): Jakamalla taulukon ko­ko­nais­ko­ko yk­sit­täi­sen elementin koolla saat taulukon ele­ment­tien lu­ku­mää­rän.
• index: Tämä edustaa elementin indeksiä tau­lu­kos­sa.

Esimerkki

Tässä esi­mer­kis­sä käytämme sizeof() mää­rit­tä­mään taulukon myArray koon sekä yk­sit­täi­sen elementin koon. Tämän tiedon avulla voimme laskea taulukon ele­ment­tien lu­ku­mää­rän jakamalla ko­ko­nais­koon yk­sit­täi­sen elementin koolla. Mittaamme elementin ja taulukon koon tavuina.

int main() {
    int myArray[] = {1, 2, 3, 4, 5};
    size_t totalSize = sizeof(myArray);
    size_t elementSize = sizeof(myArray[0]);
    size_t arrayLength = totalSize / elementSize;
    printf("Total size of the array: %d bytes\n", (int)totalSize);
    printf("Size of a single element: %d bytes\n", (int)elementSize);
    printf("Number of elements in the array: %d\n", (int)arrayLength);
    return 0;
}

Tulostus on:

Total size of the array: 20 bytes
Size of a single element: 4 bytes
Number of elements in the array: 5

Pointer-arit­me­tiik­ka

Pointerit eivät itsessään sisällä tietoa taulukon koosta tai pi­tuu­des­ta. Voimme kuitenkin käyttää pointer-arit­meet­ti­sia ope­raa­tioi­ta yhdessä taulukon ele­ment­tien osoit­tei­den kanssa mää­rit­tääk­sem­me C-taulukon pituuden.

Syntaksi

data_type arr_length = *(&arr + 1) - arr;

• &arr: Tämä luo osoit­ti­men, joka osoittaa koko ele­ment­tien tau­luk­koon.
• (&arr + 1): Tässä tau­luk­koon arr osoittava osoitin kas­va­te­taan yhdellä. Koska arr on taulukko, tämä tar­koit­taa, että osoitin osoittaa seu­raa­vaan pe­räk­käi­seen tau­luk­koon, joka on samaa tyyppiä kuin arr.

Esimerkki

Lauseke *(&arr + 1) - arr laskee seu­raa­vaan tau­luk­koon &arr + 1 osoit­ta­van osoit­ti­men ja al­ku­pe­räi­sen taulukon en­sim­mäi­seen ele­ment­tiin osoit­ta­van osoit­ti­men välisen eron. Tässä ta­pauk­ses­sa seuraava muis­tia­lue on en­sim­mäi­sen taulukon loppu. Tuloksena oleva ero on yhtä suuri kuin taulukon ele­ment­tien lukumäärä.

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int length = *(&arr + 1) - arr;
    printf("Number of elements in the array: %d\n", length);
    return 0;
}

Tulos:

Number of elements in the array: 5

For-silmukat

Toinen tapa määrittää taulukon pituus C-kielellä on käyttää for-silmukkaa. Tässä me­ne­tel­mäs­sä käydään läpi taulukko ja lasketaan sen si­säl­tä­mien ele­ment­tien määrä. Jotta tätä tek­niik­kaa voidaan käyttää, taulukon, jonka pituuden haluat määrittää, on oltava samassa koo­dia­lu­ees­sa kuin for-silmukka, jota käytät sen pituuden mää­rit­tä­mi­seen.

Esimerkki

Tässä silmukka lisää arrayLength laskuria jo­kai­sel­le lä­pi­käy­dyl­le ele­men­til­le. i < sizeof(arr) / sizeof(arr[0]) ehto varmistaa, että silmukka suo­ri­te­taan vain, jos elementit ovat tau­lu­kos­sa.

#include <stdio.h>
int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
    size_t arrayLength = 0;
    for (size_t i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
        arrayLength++;
    }
    printf("Number of elements in the array: %d\n", arrayLength);
    return 0;
}

Tulos:

Number of elements in the array: 8