uvod-u-cpp/lekcije/nizovi_uvod.md

[↩ Nazad na sadržaj](../README.md)

# Uvod u nizove

Do sada, ako ste hteli da deklarišete 5 promenljivih, morali biste da uradite nešto poput:
```c++
int i_1,i_2,i_3,i_4,i_5;
```

Šta da ste hteli da deklarišete 100 promenljivih? To bi potrajalo. I zašto bismo uopšte hteli da ikad imamo 100 promenljivih? 

Zamislite situaciju u kojoj pravimo program koji treba da analizira temperature u prethodnoj godini, i za njegov rad je potrebno sačuvati prosečne dnevne temperature za svaki dan u toj godini.

Praviti 365 * 2 promeljivih očigledno nije dobro rešenje, i nama u pomoć tu dolaze nizovi (eng. *array*). Uz pomoć nizova možemo sačuvati veliki broj podataka u samo jednoj promeljivoj, to jest da ti podaci imaju zajedničko ime. Na primer:
```c++
int temperature[365];
```

U ovom slučaju promeljiva `temperature` čuva 365 vrednoti tipa `int`, i njih možemo postavljati ili očitavati korišćenjem kvadratnih zagrada:
```c++
temperature[0] = -2;
temperature[1] = +1;
temperature[2] = +4;
```

Svaki podatak u nizu ima svoj redni broj, pri čemu odbrojavanje kreće od nule. U primeru gore vrednost u `temperature[0]` bi zapravo odgvarala prvom januaru, i postavili smo tu vrednost na -2.

Dakle, prosečna temperature u prva 3 dana u toj godini bi na primer mogla da se izračuna po formuli:
```c++
double prosek = (temperature[0] + temperature[1] + temperature[2]) / 3.0;
```

## Korišćenje nizova uz pomoć petlji

Kako niz služi za čuvanje velikog broja podataka, i kako svaki od njih ima svoj redni broj; najčešći način baratanja nizovima je unutar petlji.

Temperature u mesecu januaru možemo da ispišemo tako što pristupimo 31-om elementu niza, od 0-og do 30-og (još jednom, odbrojavanje kreće od 0!):
```c++
cout << "Temperature u januaru su:" << endl;
for(int dan = 0; dan < 31; dan++) {
    cout << temperature[dan] << endl;
}
```
---

Naravno, ovaj primer neće da radi ukoliko ne popunimo niz sa pravim vrednostima, pa u nastavku dajemo primer programa koji niz od 10 elemenata popunjava kvadratima brojeva od 0 do 9, i zatim ispisuje njegove elemente:

```c++
#include <iostream>

using namespace std;

int main()
{
    int kvadrati[10];

    for (int i = 0; i < 10; i++) {
        kvadrati[i] = i * i;
    }

    for (int i = 0; i < 10; i++) {
        cout << i << ". broj u nizu je " << kvadrati[i] << endl;
    }

    return 0;
}
```

Kada ga pokrenemo, ovaj program ispisuje:
```
0. broj u nizu je 0
1. broj u nizu je 1
2. broj u nizu je 4
3. broj u nizu je 9
4. broj u nizu je 16
5. broj u nizu je 25
6. broj u nizu je 36
7. broj u nizu je 49
8. broj u nizu je 64
9. broj u nizu je 81
```

## Određivanje dužine niza

Kao što ste primetili, prilikom stvaranja (deklaracije) niza potrebno mu je dati neku dužinu - broj elemenata u tom nizu. Dužina niza ne može da se promeni nakon stvaranja. Štoviše, dužina mora biti poznata pre pokretanja programa, te ne možemo koristiti promenljive za njeno postavljanje.

Dakle, sledeći kod **nije dozvoljen**:
```c++
int n;
cin >> n;
int niz[n]; // ovo ne sme!
```

Kako onda rešiti zadatak u kom je potrebno napraviti niz baš dužine `n`? Obično će nam unapred biti poznat opseg mogućih vrednosti za `n`, na primer da važi `1 ≤ n ≤ 1000`. U takvom slučaju dužinu niza ćemo postaviti na najveću moguću vrednost `n`, u ovom slučaju 1000:
```c++
int n;
cin >> n;
int niz[1000]; // sve OK
```

Ovakav kod će da radi, ali će deo niza ostati neiskorišćen. Za `n = 10`, 990 od 1000 ostaju neiskorišćeni. U praksi se to rešava korišćenjem dinamičkih nizova, odnosno strukture `vector`, ali o tome kasnije : )