# Kuidas määrata massiivi pikkus C-keeles

C-keeles saab massiivide pikkust usaldusväärselt määrata mitmesuguste meetodite abil. See lihtsustab massiivide dünaamilist haldamist ja suuruse muutustega kohanemist.

## Mis on massiivi pikkus C-keeles ja millised meetodid on selle mõõtmiseks olemas?

Kui mõõdate massiivi pikkust C-keeles, mõõdate massiivi sisaldavate **elementide arvu**. See teave on oluline massiivi üksikute elementide juurdepääsuks, massiivi läbimiseks või manipuleerimiseks. Kui deklareerite massiivi C-keeles, eraldatakse massiivi elementide jaoks mälu RAM-is järjestikku (st järjestikku ilma vahedeta). C-keeles pole massiivi pikkuse määramiseks sisseehitatud funktsiooni, seega peate selle käsitsi määrama.

Kõige levinumad meetodid on:

- **`sizeof()`**
- **Viitearitmeetika**
- **Tsüklid**

## `sizeof()`

`sizeof()` C-keeles operaator. See määrab kompileerimise ajal **andmetüübi või muutuja suuruse baitides**. Operaatori `sizeof` tagastatav tüüp on `size_t`, mis on märgita täisarv, mis esindab suurust baitides. C-keeles saab massiivi pikkuse arvutamiseks kasutada ka funktsiooni `sizeof()`.

### Süntaks

Massiivi elementide arvu määramiseks tuleb massiivi kogumaht jagada ühe elemendi mahuga.

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

- **data\_type**: See on andmetüüp, kus salvestatakse massiivi pikkus.
- **array\_name**: Määrab massiivi nime.
- **sizeof(array\_name)**: See väljend tagastab massiivi kogumahu baitides.
- **sizeof(array\_name\[index\])**: Jagades massiivi kogumahu ühe elemendi suurusega, saad massiivi elementide arvu.
- **index**: See tähistab elemendi indeksit massiivis.

### Näide

Selles näites kasutame `sizeof()`, et määrata massiivi `myArray` suurus ja ühe elemendi suurus. Selle teabe abil saame arvutada massiivi elementide arvu, **jagades kogumassiivi suurus ühe elemendi suurusega**. Mõõdame elemendi ja massiivi suurust baitides.

```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;
}
```

Väljund on:

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

## Viitearitmeetika

Viited ise ei sisalda teavet massiivi suuruse või pikkuse kohta. Siiski saame C-massiivi pikkuse kindlaks määrata, kasutades viitearitmeetikat koos **massiivi elementide aadressidega**.

### Süntaks

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

- **`&arr`**: See loob viite, mis osutab kogu elementide massiivile.
- **`(&arr + 1)`**: Siin suurendatakse massiivi `arr` osutavat viitajat 1 võrra. Kuna `arr` on massiiv, tähendab see, et viitaja osutab järgmisele järjestikusele massiivile, mis on sama tüüpi kui `arr`.

### Näide

Väljend `*(&arr + 1) - arr` arvutab järgmise massiivi `&arr + 1` osutava viite ja algse massiivi esimese elemendi osutava viite vahe. Sel juhul on „järgmine” mäluala esimese massiivi lõpp. Saadud vahe on võrdne massiivi elementide arvuga.

```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;
}
```

Väljund:

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

## For-tsüklid

Teine meetod massiivi pikkuse määramiseks C-keeles on **for-tsükli** kasutamine. See meetod hõlmab massiivi läbikäimist ja selles sisalduvate elementide arvu loendamist. Selle meetodi kasutamiseks peab massiiv, mille pikkust soovite määrata, asuma samas koodivaldkonnas kui for-tsükkel, mida kasutate selle pikkuse määramiseks.

### Näide

Siin suurendab tsükkel `arrayLength` loendurit iga läbitud elemendi puhul. `i < sizeof(arr) / sizeof(arr[0])` tingimus tagab, et tsükkel töötab ainult siis, kui elemendid on massiivis.

```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;
}
```

Väljund:

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


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/c-massiivi-pikkus/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/c-massiivi-pikkus/) for AI/LLM consumption.