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

C-kielessä voit määrittää taulukoiden pituuden luotettavasti useilla eri menetelmillä. Näin taulukoiden hallinta on helpompaa ja ne voidaan mukauttaa koon muutoksiin dynaamisesti.

## Mikä on taulukon pituus C-kielessä ja mitä menetelmiä sen mittaamiseen on olemassa?

Kun mitataan taulukon pituutta C-kielellä, mitataan taulukon sisältämien **elementtien lukumäärää**. Tämä tieto on ratkaisevan tärkeää, kun halutaan käyttää taulukon yksittäisiä elementtejä, käydä taulukko läpi tai suorittaa manipulointeja. Kun taulukko määritellään C-kielellä, taulukon elementtien muisti varataan RAM-muistiin peräkkäin (eli järjestyksessä ilman aukkoja). C-kielessä ei ole sisäänrakennettua funktiota taulukon pituuden määrittämiseen, joten se on määritettävä manuaalisesti.

Yleisimmät menetelmät ovat:

- **`sizeof()`**
- **Pointer-aritmetiikka**
- **Silmukat**

## `sizeof()`

`sizeof()` operaattori C-kielessä. Se määrittää **datatyypin tai muuttujan koon tavuina** käännösajon aikana. Operaattorin `sizeof` palautustyyppi on `size_t`, unsigned integer -tyyppi, joka edustaa kokoa tavuina. C-kielessä voit myös käyttää `sizeof()` taulukon pituuden laskemiseen.

### Syntaksi

Jotta voit määrittää taulukon elementtien lukumäärän, sinun on jaettava taulukon kokonaiskoko yksittäisen elementin koolla.

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

- **data\_type**: Tämä on tietotyyppi, johon taulukon pituus tallennetaan.
- **array\_name**: Määrittää taulukon nimen.
- **sizeof(array\_name)**: Tämä lauseke palauttaa taulukon kokonaiskoon tavuina.
- **sizeof(array\_name\[index\])**: Jakamalla taulukon kokonaiskoko yksittäisen elementin koolla saat taulukon elementtien lukumäärän.
- **index**: Tämä edustaa elementin indeksiä taulukossa.

### Esimerkki

Tässä esimerkissä käytämme `sizeof()` määrittämään taulukon `myArray` koon sekä yksittäisen elementin koon. Tämän tiedon avulla voimme laskea taulukon elementtien lukumäärän **jakamalla kokonaiskoon yksittäisen elementin koolla**. Mittaamme elementin ja taulukon koon tavuina.

```c
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:

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

## Pointer-aritmetiikka

Pointerit eivät itsessään sisällä tietoa taulukon koosta tai pituudesta. Voimme kuitenkin käyttää pointer-aritmeettisia operaatioita yhdessä **taulukon elementtien osoitteiden** kanssa määrittääksemme C-taulukon pituuden.

### Syntaksi

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

- **`&arr`**: Tämä luo osoittimen, joka osoittaa koko elementtien taulukkoon.
- **`(&arr + 1)`**: Tässä taulukkoon `arr` osoittava osoitin kasvatetaan yhdellä. Koska `arr` on taulukko, tämä tarkoittaa, että osoitin osoittaa seuraavaan peräkkäiseen taulukkoon, joka on samaa tyyppiä kuin `arr`.

### Esimerkki

Lauseke `*(&arr + 1) - arr` laskee seuraavaan taulukkoon `&arr + 1` osoittavan osoittimen ja alkuperäisen taulukon ensimmäiseen elementtiin osoittavan osoittimen välisen eron. Tässä tapauksessa seuraava muistialue on ensimmäisen taulukon loppu. Tuloksena oleva ero on yhtä suuri kuin taulukon elementtien lukumäärä.

```c
#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:

```c
Number of elements in the array: 5
```

## For-silmukat

Toinen tapa määrittää taulukon pituus C-kielellä on käyttää **for-silmukkaa**. Tässä menetelmässä käydään läpi taulukko ja lasketaan sen sisältämien elementtien määrä. Jotta tätä tekniikkaa voidaan käyttää, taulukon, jonka pituuden haluat määrittää, on oltava samassa koodialueessa kuin for-silmukka, jota käytät sen pituuden määrittämiseen.

### Esimerkki

Tässä silmukka lisää `arrayLength` laskuria jokaiselle läpikäydylle elementille. `i < sizeof(arr) / sizeof(arr[0])` ehto varmistaa, että silmukka suoritetaan vain, jos elementit ovat taulukossa.

```c
#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:

```c
Number of elements in the array: 8
```


This is a markdown version of: [https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/c-taulukon-pituus/](https://www.ionos.com/fi-fi/digitalguide/verkkosivustot/verkkosivujen-kehittaeminen/c-taulukon-pituus/) for AI/LLM consumption.