# Kako določiti dolžino niza v C

Dolžino nizov v jeziku C lahko zanesljivo določite z različnimi metodami. To olajša dinamično upravljanje nizov in prilagajanje spremembam velikosti.

## Kaj je dolžina niza v C in kakšne metode obstajajo za njegovo merjenje?

Ko merite dolžino niza v C, merite **število elementov, ki jih** niz vsebuje. Ta informacija je ključna za dostop do posameznih elementov v nizu, prehod skozi niz ali izvajanje manipulacij. Ko deklarirate niz v C, se pomnilnik za elemente v nizu dodeli v RAM-u neprekinjeno (tj. zaporedno brez vrzeli). V jeziku C ni vgrajene funkcije za določanje dolžine niza, zato jo morate določiti ročno.

Najpogostejše metode so:

- **`sizeof()`**
- **Aritmetika kazalcev**
- **Zank**

## `sizeof()`

`sizeof()` operator v jeziku C. Določa **velikost podatkovnega tipa ali spremenljivke v bajtih** med prevajanjem. Vrsta vrnitve operatorja `sizeof` je `size_t`, nepodpisani celoštevilčni tip, ki predstavlja velikost v bajtih. V jeziku C lahko za izračun dolžine niza uporabite tudi funkcijo `sizeof()`.

### Sintaksa

Da bi določili število elementov v nizu, morate skupno velikost niza deliti z velikostjo posameznega elementa.

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

- **data\_type**: To je tip podatkov, v katerem bo shranjena dolžina niza.
- **array\_name**: Določa ime niza.
- **sizeof(ime\_niza)**: Ta izraz vrne skupno velikost niza v bajtih.
- **sizeof(array\_name\[index\])**: S delitvijo skupne velikosti niza z velikostjo posameznega elementa dobite število elementov v nizu.
- **index**: To predstavlja indeks elementa v nizu.

### Primer

V tem primeru bomo uporabili `sizeof()` za določitev velikosti niza `myArray` in velikosti posameznega elementa. S temi podatki lahko nato izračunamo število elementov v nizu, tako da **skupno velikost delimo z velikostjo posameznega elementa**. Velikost elementa in niza bomo merili v bajtih.

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

Izhod je:

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

## Aritmetika kazalcev

Kazalci sami po sebi ne vsebujejo informacij o velikosti ali dolžini niza. Vendar pa lahko uporabimo aritmetiko kazalcev skupaj z **naslovi elementov niza**, da določimo dolžino niza v jeziku C.

### Sintaksa

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

- **`&arr`**: To ustvari kazalec, ki kaže na celoten niz elementov.
- **`(&arr + 1)`**: Tukaj se kazalec, ki kaže na niz `arr`, poveča za 1. Ker je `arr` niz, to pomeni, da bo kazalec kazal na naslednji zaporedni niz, ki je istega tipa kot `arr`.

### Primer

Izraz `*(&arr + 1) - arr` izračuna razliko med kazalcem, ki kaže na naslednji niz `&arr + 1`, in kazalcem, ki kaže na prvi element izvirnega niza. V tem primeru je „naslednje“ pomnilniško območje konec prvega niza. Rezultatna razlika je enaka številu elementov v nizu.

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

Izhod:

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

## Za zanke

Druga metoda za določanje dolžine niza v C je uporaba **zanke for**. Ta pristop vključuje ponavljanje skozi niz in štetje števila elementov, ki jih vsebuje. Da bi uporabili to tehniko, mora biti niz, katerega dolžino želite določiti, v istem obsegu kode kot zanka for, ki jo uporabljate za določanje njegove dolžine.

### Primer

Tukaj zanka poveča število `arrayLength` za vsak element, ki je prenesen. Pogoj `i < sizeof(arr) / sizeof(arr[0])` zagotavlja, da zanka teče samo, če so elementi v nizu.

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

Izhod:

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


This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/c-dolzina-niza/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/c-dolzina-niza/) for AI/LLM consumption.