Podatkovni tipi¶

Omejitve¶

Mnogo bolj podrobno in pravilno tabelo najdete tukaj.

Naj vas to ne prestraši, pametno je poznati omejitve, a mi bomo ponavadi za cela števila uporabljali kar int in za decimalna double. (Float je precej nenatančen, kar je na tekmovanjih, ali pa za kakšne resne izračune problematično. Je pa lahko npr. uporabno v računalniški grafiki, kjer je na koncu pomembna le natančnost na en piksel. Pred celoštevilske tipe lahko vtaknemo tudi unsigned, ki razpon števila premakne na pozitivno os. Če število povečamo čez razsežnost tipa, se ne zgodi na videz nič, številka se samo navije okrog spodnje meje. Torej, če rečemo char a = 130; bo a v resnici enak -126.

Decimalna števila zaokrožujejo in zaradi tega se pojavljajo napake. Obstaja zelo močna veja matematike, ki se ukvarja s preučevanjem in odpravljanjem teh napak, ampak za nas bo dovolj, da se samo zavedamo, da obstajajo. Če na primer 10 krat seštejete 0.1, to ni nujno enako celemu številu 1 (if stavek se lahko recimo ne izvede, če je kaj takega v pogoju). Dveh decimalnih števil nikoli ni pametno direktno preverjati, ali sta enaki, ponavadi se za mero enakosti vzame kaj podobnega kot abs(a - b) < -1e9. Decimalna števila imajo omejitve tudi glede tega, kako blizu 0 lahko pridejo (vsa lahko predstavijo točno 0). Podobne omejitve za decimalna števila veljajo tudi v Pythonu in ostalih programskih jezikih.

Pretvorbe¶

Med tipi lahko med pretvarjamo, poznamo implicitne in eksplicitne pretvorbe. Compiler bo avtomatsko naredil pretvorbe, ki ne škodujejo “kvaliteti” tipa, pri pretvorbi iz npr. double v int pa bo posvaril vsaj z opozorilom. Tako pretvorbo lahko sami naredimo na več načinov (ki so glede na rezultat ekvivalentni):

int a = static_cast<int>(12.34);
int b = int(12.34);
int c = (int) 12.34;

Če uporabimo static_cast, to dovoljuje prevajalniku, da preveri, da ne počnemo česa preveč nepravilnega. Ostale pretvorbe te varnosti nimajo.

Dostopanje in spreminjanje elementov¶

Vektor podpira operator [], s katerim dostopamo in spreminjamo element na določenem indeksu:

vector<int> b({12, 4, 7, -12, 44});
b[1] = 3;
cout << b[2] << ' ' << b[1] << endl;
// izpiše 7 3

Iteratorji¶

Iterator je objekt, ki vsebuje podatek o svoji poziciji v neki zbirki. Na nek način je podoben indeksu. Iteratorji so mnogo bolj uporabni kot vrednosti v zbirki same. Poglejmo si to na primeru indeksov. V seznamu najdemo vrednost 5. Kaj na ta vrednost pove? Nič prav dosti, ali vemo katera je naslednja, katera je prejšnja, ali smo na začetku? Če pa poznamo indeks vrednosti, recimo vrednost 5 je na mestu 2, potem na vprašanja lažje odgovorimo. Iteratorji so torej neke vrste objekti, ki hranijo pozicijo v zbirki in lahko dostopajo do vrednosti na tem mestu, gredo na naslednje mesto, preverijo ali smo na koncu ... Poleg tega so po tipu različni od števil, kar omogoča manj napak, saj nas compiler na morebitno neujemanje tipov vedno opozori.

Pomembne operacije ki jih lahko počnemo z iteratorji (ne vsemi, nekateri ne podpirajo vsega tega) so: dobivanje vrednosti, povečevanje in zmanjševanje, povečevanje in zmanjševanje za dano število, računanje razlike med dvema iteratorjema (razdalje). Seveda jih lahko tudi primerjamo. Pridobivanju vrednosti iz iteratorja se reče dereferenciranje.

vector<int> a({12, 4, 5, -2, 11});      // tip iteratorja po zbirki je 'zbirka::iterator'
vector<int>::iterator it = a.begin();   // .begin() vrne iterator, ki kaže na začetek zbirke
cout << *it << endl;                    // vrednost dobimo z operatorjem *
++it;                                   // povečamo za 1
cout << *it << endl;
it += 3;                                // povečamo za 3
if (it + 1 == a.end()) {                // se izpiše
    cout << "konec!" << endl;           // .end() vrne iteartor, ki kaže čez konec vektorja
}
cout << a.end() - a.begin() << endl;    // to je zato da a.end() - a.begin() vrne dolžino

Iteratorjev ali seznamov samih se ne da izpisati, seznam lahko izpišete s for zanko, iterator pa lahko izpišete kot številski indeks tako, da izpišete it - a.begin(). Napaka, ki jo prevajalnik javi pri tem je podobna temu:

a.cpp:8:10: error: invalid operands to binary expression
        ('ostream' (aka 'basic_ostream<char>') and 'vector<int>')
    cout << a << endl;
    ~~~~ ^  ~
/usr/bin/../lib64/gcc/x86_64-unknown-linux-gnu/4.9.1/../../../../include/c++/4.9.1/ostream:245:7:
note: candidate function not viable: no known conversion from
        'vector<int>' to 'int' for 1st argument
    operator<<(int __p)
    ^

To se je potrebno malo naučiti brati. Prvi vrstici povesta napako: v ostream (= output stream = cout) ste poskusili zatlačiti vector<int>, kar se ne da. Ostalih 80 info napak vam pove kaj pa se v ostream da zatlačiti, npr. int.

Spreminjanje vektorja¶

Tu so funkcije s katerimi lahko spreminjamo vektor. Pred vsako funkcijo piše tip, ki ga vrača, pišejo pa tudi tipi parametrov. Funkcije so poenostavljene za lažje razumevanje. T pomeni katerikoli tip se pač odločimo, da bo naš vektor vseboval. void pomeni, da funkcija ne vrača ničesar.

template <typename T> vector

iterator begin()¶

Vrne iterator, ki kaže na prvi element vektorja.

iterator end()¶

Vrne iterator, ki kaže čez zadnji element vektorja.

int size()¶

Vrne velikost (dolžino) vektorja.

iterator insert(iterator pos, T vrednost)¶

Vstavi element na mesto pred iterator pos in vrne iterator na novo vstavljeni element. Vsi elementi za tem se premaknejo za eno mesto nazaj, tako da ta operacija lahko traja dolgo.

iterator erase(iterator pos)¶

Izbriše element, na katerega kaže pos. Vektor je za en element krajši, vsi elementi za izbrisanim se premaknejo eno mesto naprej, tako da ta operacija lahko traja dolgo.

void push_back(T vrednost)¶

Doda vrednost na konec vektorja.

void pop_back()¶

Zbriše zadnji element iz vektorja.

Primer:

vector<int> a({1, 2, 3});                                 // [1, 2, 3]
a.push_back(4);                                           // [1, 2, 3, 4]
a.push_back(5);                                           // [1, 2, 3, 4, 5]
a.pop_back();                                             // [1, 2, 3, 4]
vector<int>::iterator it = a.insert(a.begin() + 1, 100);  // [1, 100, 2, 3, 4]
a.erase(it + 2);                                          // [1, 100, 2, 4]
cout << a.size() << endl;                                 // izpiše 4

Pari¶

C++ definira pare, to so objekt, ki lahko držijo dva različna tipa. Definira se jih s kot pair<A, B> par;, kjer sta A in B tipa elementov v paru. Do elementov dostopamo z atributoma .first in .second. Par lahko tudi naredimo s funkcijo make_pair.

pair<int, string> par = make_pair(12, "asdfasdf");  // lahko tudi = {12, "asdfasdf"}
cout << "(" << par.first << ", " << par.second << ")\n";

Uporaba asociativnih seznamov¶

Mapi podpirajo dodajanje in dostopanje do elementov z uporabo operatorja [].

template <typename K, typename V> map

int size()

Vrne število elementov v mapu.

int erase(K kljuc)¶

Zbriše element s ključem ključ, če obstaja in vrne število izbrisanih argumentov.

int find(K kljuc)¶

Vrne število elementov s ključem kljuc, torej 0 ali 1.

Primer uporabe:

map<char, int> counter;
string znaki = "abeceda";
for (int i = 0; i < znaki.length(); ++i) {
    counter[znaki[i]]++;    // pri danem znaku povečamo count
}
for (map<char, int>::iterator it = counter.begin(); it != counter.end(); ++it) {
  cout << it->first << " => " << it->second  << endl;
}
// Izpis:
// a => 2
// b => 1
// c => 1
// d => 1
// e => 2

Tukaj bi morali po vseh pravilih do sedaj napisati (*it).first (torej, najprej dobimo vrednost, in potem dobimo first te vrednosti, toda C++ to poenostavi in definira operator x->y, ki pomeni natanko (*x).y.

Range for zanka¶

Za vsako zbirko, ki definira .begin() in .end() iteratorja, ki podpirata ++it, *it in !=, se lahko uporablja range for zanko. Vse zbirke opisane zgoraj, te metode definirajo.

Torej lahko za vektor v, če nas indeksi njegovih elementov ne zanimajo, ali pa morda naša zbirka sploh ne podpira dostopa po indeksih, namesto:

for (vector<int>::iterator it = v.begin(); it != v.end(); ++it) {
    // počni nekaj z *it
}

napišemo:

for (int x : v) {
    // počni nekaj z x
}

Paziti je potrebno, da se v tem primeru ustvari kopija x, in da če x spremenimo, to nima vpliva na v. A je tudi to rešljivo. Zgornja verzija v nobenem primeru ni optimalna, če vrednosti ne želimo spreminjati, napišemo

for (const int& x : v) {
    // počni nekaj z x
}

kar prepreči kopiranje x, saj je x dejanski objekt iz v. Če const izpustimo, lahko x tudi spreminjamo, kar bo spremenilo tudi elemente v. Več o referencah (to so tisti & znaki) v poglavju Funkcije. Tip int lahko nadomestimo tudi z auto, da nam ni potrebno pisati zelo dolgih tipov, pri čemer še vedno popolnoma veljavno uporabljamo npr. auto& x z enakim pomenom kot prej.