Cpp.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f97b1299-e33b-4778-b273-8cc05e7edf4b",
   "metadata": {},
   "source": [
    "# C++\n",
    "\n",
    "V C-ju že znate programirati, C++ pa vam ponuja nekaj dodatnih funkcionalnosti, ki vam bodo olajšale življenje. Večinoma preko svoje standardne knjižnice in raznih sintaktičnih bližnjic. Standardna knjižnica vsebuje številne uporabne podatkovne tipe/strukture (*containters*) in algoritme. Osnovana je bila po knjižnici Standard Template Library (STL), ki se še danes pogosto uporablja kar kot sinonim za C++ standardno knjižnico.\n",
    "\n",
    "Prav vam bo prišla dokumentacija:\n",
    "- [cplusplus](https://cplusplus.com/reference/)\n",
    "- [cppreference](https://en.cppreference.com/w/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64872ce4-3b72-44a3-bd72-2f3cdd1d3ba6",
   "metadata": {},
   "source": [
    "## Branje in pisanje\n",
    "\n",
    "V C-ju ste navajeni branja in pisanja podatkov s knjižnico `stdin.h`in funkcijami kot so `scanf`, `printf`, `gets`, ...\n",
    "\n",
    "C++ pa v knjižnici `iostream` ponuja t.i. tokove (*stream*). Prav nam bosta prišla `cin` (character input) in `cout` (character output). Podpirata operatorje `>>` oz. `<<`, ki poleg branja/pisanja tudi vrneta isti objekt, da lahko operatorje verižimo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1dcc50f5-1ebe-40d5-b7bb-c7420cc7a3ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <iostream>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a79a9c5f-d217-45e9-8f2f-395194ae5ce1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Zivjo!\n"
     ]
    }
   ],
   "source": [
    "std::cout << \"Zivjo!\\n\";"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c423e4da-dfcb-4064-9752-587b4fb139ad",
   "metadata": {},
   "source": [
    "Večina funkcionalnosti, ki jih ponuja C++ v svoji standardni knjižnici, se nahaja v imenskem prostoru `std`, do objektov v njem pa dostopamo z `std::ime`. Malo pisanja si lahko prihranimo z deklaracijo uporabe imenskega prostora `std`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f7175fb2-367e-4906-a233-dbbe7020cbf7",
   "metadata": {},
   "outputs": [],
   "source": [
    "using namespace std;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e695fd14-3785-4694-872f-da431ca092f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " 9 10\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vsota = 19\n"
     ]
    }
   ],
   "source": [
    "int a,b;\n",
    "cin >> a >> b;\n",
    "cout << \"vsota = \" << a+b << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce53fb78-d005-46c8-9e92-0bbbbaa2662f",
   "metadata": {},
   "source": [
    "## Nizi\n",
    "\n",
    "C++ ponuja podatkovno strukturo `string`, ki nam olajša delo z nizi v primerjavi s C-jem, kjer smo bili obsojeni na delo s tabelami znakov."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1e3cfe1b-7947-4d45-8d0e-7ecddf4e8a97",
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <string>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "71019e97-5ae2-4732-bdb0-a9349acb6aef",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      " Tomaz Hocevar\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pozdravljen, Hocevar Tomaz!\n",
      "Zacetnice: TH\n",
      "Dolzina imena: 5\n"
     ]
    }
   ],
   "source": [
    "string ime, priimek;\n",
    "cin >> ime >> priimek;\n",
    "string oseba = priimek + \" \" + ime;\n",
    "cout << \"Pozdravljen, \" << oseba << \"!\" << endl;\n",
    "cout << \"Zacetnice: \" << ime[0] << priimek[0] << endl;\n",
    "cout << \"Dolzina imena: \" << ime.size() << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0af7ca4-ddd3-4b79-8bb0-e6c882393575",
   "metadata": {},
   "source": [
    "## Pari\n",
    "\n",
    "Pari vrednosti so zelo koristni, da nam ni treba za vsako malenkost ustvarjati novih struktur ali razredov. V jezikih, kot je npr. Python, pa je koncept terk (*tuple*) še bolj prisoten. Paru moramo določiti tudi tipe vsebovanih komponent. Sintaksa z \"oklepaji\" oz. znaki manjše/večje je podobna tisti, ki ste je navajeni iz Jave. Do obeh elementov dostopamo preko atributov `first` in `second`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c9f31bd1-4d66-4ca6-a05c-0cfe4ed81105",
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <utility>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "5869755f-b1ad-4837-b88d-9e8a7a2af87f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 12\n"
     ]
    }
   ],
   "source": [
    "pair<int,int> xy;\n",
    "xy = make_pair(10,12);\n",
    "cout << xy.first << \" \" << xy.second << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6de81b82-08f9-4d5c-b49b-81aa24c03098",
   "metadata": {},
   "source": [
    "### Inicializacija s seznamom\n",
    "\n",
    "Nekatere podatkovne tipe lahko inicializiramo tudi s seznami vrednosti (initializer list). Poleg parov bomo videli primere uporabe tudi kasneje pri drugih strukturah."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "32ea28d1-7d21-47a3-b95b-0ebeb3d0cbb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 3\n"
     ]
    }
   ],
   "source": [
    "pair<int,int> p = {2,3};\n",
    "cout << p.first << \" \" << p.second << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "242dca25-4a89-4cd7-b7e3-dd2d69c908b3",
   "metadata": {},
   "source": [
    "### Avtomatska določitev tipa\n",
    "\n",
    "Ko začnemo uporabljati gnezdene strukture (npr. par osebe in ocene, pri čemer je oseba prav tako par sestavljen iz imena in priimka), postanejo opisi podatkovnih tipov precej dolgi. Ker zna prevajalnik med prevajanjem ugotoviti, da se nek tip ne ujema, ga lahko tudi kar določi, kar označimo s tipom `auto`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5b8bf368-1cf4-4505-8223-4831db86e2ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tomaz\n"
     ]
    }
   ],
   "source": [
    "pair<pair<string,string>, int> ocena = {{\"Tomaz\", \"Hocevar\"}, 10};\n",
    "auto o = ocena;\n",
    "cout << o.first.first << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df67b5e7-b12f-43d9-b153-acf3d5b19d4f",
   "metadata": {},
   "source": [
    "## Seznam\n",
    "\n",
    "V C-ju smo imeli na voljo tabele fiksne velikosti. Če smo želeli hraniti seznam elementov, ki smo ga podaljševali, pa smo naleteli na manjši problem. Tega nam rešuje poatkovnih tip `vector`, ki predstavlja razširljivo tabelo (*resizable array*), podobno kot ArrayList v Javi. V njem lahko shranjujemo samo elemente enakega tipa, ki ga moramo navesti ob deklaraciji (za razliko od npr. Pythona)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e0ed2dd5-4798-4e20-9506-5bff43a5280c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <vector>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4aec34f9-e5c4-4c18-86dd-59118b039466",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 4 8 16 32 64 128 256 512 1024 \n"
     ]
    }
   ],
   "source": [
    "vector<int> v;\n",
    "for (int x=1; x<=1024; x*=2) v.push_back(x);\n",
    "for (int i=0; i<v.size(); i++) cout << v[i] << \" \";\n",
    "cout << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a91a7bbc-5a9f-431e-b379-b47187fd3f31",
   "metadata": {},
   "source": [
    "### Iteratorji\n",
    "\n",
    "Koncept iteratorjev vam je že poznan iz Jave. V C++ so iteratorji kazalci na elemente v strukturah, s katerimi se lahko premikamo po elementih v tej strukturi. Vsaka struktura ima svoj tip iteratorja (npr. ``vector<int>::iterator) in ponuja iteratorja na svoj začetek in konec (`.begin()` in `.end()`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "995e5b3c-f85d-4b48-9dec-960b652a9117",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 4 8 16 32 64 128 256 512 1024 \n"
     ]
    }
   ],
   "source": [
    "for (vector<int>::iterator it=v.begin(); it!=v.end(); it++) {\n",
    "    cout << *it << \" \";\n",
    "}\n",
    "cout << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e380b4c-f09e-4a8f-bd0a-5ff71246c0b2",
   "metadata": {},
   "source": [
    "### For each\n",
    "\n",
    "Iteracija čez vse elemente strukture je zelo pogosta operacija, zato je v številnih programskih jezikih na voljo tudi temu prilagojena sintaksa. V C++ je to `for (tip element : struktura)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "871e898c-bc93-480f-8b15-0cfb614c2eb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 6]\n",
      "[1, 4]\n",
      "[-2, 6]\n"
     ]
    }
   ],
   "source": [
    "vector<pair<int,int>> koordinate = {{2,6},{1,4},{-2,6}};\n",
    "for (pair<int,int> xy : koordinate) cout << \"[\" << xy.first << \", \" << xy.second << \"]\" << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8020fbb-a486-4a4a-9efd-02c3210e7574",
   "metadata": {},
   "source": [
    "### Razpakiranje \n",
    "\n",
    "Dostop do posameznih elementov kompleksnejšega tipa (npr. seznama parov) je lahko kar dolg. To si lahko skrajšamo z uporabo razpakiranja (*structured binding declaration*). Sintaksa je `auto [a, b, ...] = x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "65ce29df-0412-4d7f-a236-66512e7c0ff9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 6]\n",
      "[1, 4]\n",
      "[-2, 6]\n"
     ]
    }
   ],
   "source": [
    "for (auto [x, y] : koordinate) cout << \"[\" << x << \", \" << y << \"]\" << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab1aa0c5-1aae-4ef6-b1e5-a603d3c81130",
   "metadata": {},
   "source": [
    "## Vrsta, sklad, slovar, množica, povezani seznam, ...\n",
    "\n",
    "C++ pozna še cel kup drugih podatkovnih tipov, kot so `queue`, `stack`, `map`, `set`, `list` ... Več o njih pa takrat, ko bomo obravnavali abstraktne podatkovne tipe."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "bf19cc9b-cfdc-4737-808d-8ef231fbad3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <map>\n",
    "#include <set>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "0bad86e6-d727-4329-803e-58d932a16967",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123\n",
      "789\n"
     ]
    }
   ],
   "source": [
    "map<string,int> vpisna = {{\"Ana\", 123}, {\"Miha\", 456}, {\"Tine\", 789}};\n",
    "set<string> prisotni = {\"Ana\", \"Tine\"};\n",
    "for (auto ime : prisotni) cout << vpisna[ime] << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4d11712-146f-45ef-8ae3-238623ac2be8",
   "metadata": {},
   "source": [
    "## Reference\n",
    "\n",
    "Referenca je drugo ime za isto spremenljivko. Označimo jo s znakom `&`. V spodnjem primeru je `y` referenca na spremenljivko tipa `int`, kar zapišemo kot `int &y`. Referenca ne more biti prazna, inicializirati jo moramo z drugo spremenljivko ob deklaraciji. Deklaracija reference brez inicializacije (`int &y;`) ali inicializacija s konstantno vrednostjo (`int &y = 9;`) nista možni."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6780da5d-491c-4991-a47c-c060aaf658e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 10\n"
     ]
    }
   ],
   "source": [
    "int x = 10;\n",
    "int &y = x;\n",
    "cout << x << \" \" << y << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f503e8b2-cabd-4a7e-b980-a08324201217",
   "metadata": {},
   "source": [
    "Če sedaj spremenimo vrednost spremenljivke `x`, se ta sprememba odraža tudi v spremenljivki `y`, in obratno."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "e961a136-1733-45a7-83e2-cf7b3ec14685",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 11\n",
      "12 12\n"
     ]
    }
   ],
   "source": [
    "x = 11;\n",
    "cout << x << \" \" << y << endl;\n",
    "y = 12;\n",
    "cout << x << \" \" << y << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce8affda-acf2-42e6-a68c-0561f2c0e611",
   "metadata": {},
   "source": [
    "V C++ se argumenti funkcij *prenašajo po vrednosti*. Funkcija torej prejme kopijo podanega argumenta. V Pythonu ali Javi bi z dodajanjem elementov seznamu, ki ga sprejme funkcija, spremenili tudi zunanji seznam. V C++ temu ni tako."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c03b5208-d90f-4343-9f94-96cdf8846689",
   "metadata": {},
   "outputs": [],
   "source": [
    "void izpisi(vector<int> v) {\n",
    "    for (int x : v) cout << x << \" \";\n",
    "    cout << endl;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1cd29faa-5097-4559-bc03-33a3ba4ca6e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "auto podvoji(vector<int> v) {\n",
    "    int n=v.size();\n",
    "    for (int i=0; i<n; i++) {\n",
    "        v.push_back(v[i]);\n",
    "    }\n",
    "    return v;\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7fe61ad3-f0be-40d9-8ff5-beec1869782d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 \n",
      "1 2 3 4 5 1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "vector<int> a = {1,2,3,4,5};\n",
    "vector<int> b = podvoji(a);\n",
    "izpisi(a);\n",
    "izpisi(b);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "09e4205e-98f5-42a6-a60d-e10f8c09dfac",
   "metadata": {},
   "source": [
    "Če želimo, lahko to funkcionalnost dosežemo s *prenosom argumentov po referenci*. Funkcija `podvoji_ref` sprejme argument po referenci, vrednost te spremenljivke spremeni in ne vrne ničesar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "fd2c833d-6db6-4b56-8e4a-4d5a1c019dd8",
   "metadata": {},
   "outputs": [],
   "source": [
    "void podvoji_ref(vector<int> &v) {\n",
    "    int n=v.size();\n",
    "    for (int i=0; i<n; i++) {\n",
    "        v.push_back(v[i]);\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "edba7dd0-014a-427d-8ba7-82f15a7c8ecb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "podvoji_ref(a);\n",
    "izpisi(a);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3e8f53d-62a4-4cb1-80b9-614a8cbd3bb8",
   "metadata": {},
   "source": [
    "Prenos po referenci se uporablja za podajanje velikih spremenljivk, da se izognemo ustvarjanju kopije. Druga pogosta uporaba je vračanje več vrednosti iz funkcije preko nastavljanja argumentov, ki so podani po referenci. Slednje smo v C-ju lahko dosegli tako, da smo funkciji podali kazalec na spremenljivko in jo nato spreminjali preko tega kazalca."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "212b2554-ab6d-4521-9ca9-9b5d6fc8b1a9",
   "metadata": {},
   "source": [
    "V spodnjem primeru funkcija `stat` sprejme seznam celih števil `v` po referenci, da se ne ustvari kopija po nepotrebnem, ker funkcija seznama ne spreminja. Prešteje pozitivna in negativna števila ter rezultate vpiše v argumenta `poz` in `neg`, ki sta prav tako podana po referenci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4417436f-1d50-48c4-ab29-b88f265313e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "void stat(vector<int> &v, int &poz, int &neg) {\n",
    "    poz=0;\n",
    "    neg=0;\n",
    "    for (int x : v) {\n",
    "        if (x>0) poz++;\n",
    "        if (x<0) neg++;\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "acc45f5a-fcfa-491c-9d7c-f92e2f24750a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "poz/neg: 3 5\n"
     ]
    }
   ],
   "source": [
    "vector<int> st = {5, -7, 8, 9, -3, -2, -1, -4};\n",
    "int poz, neg;\n",
    "stat(st, poz, neg);\n",
    "cout << \"poz/neg: \" << poz << \" \" << neg << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18a5a3e8-c94e-4d52-a80b-4e63dc900b8c",
   "metadata": {},
   "source": [
    "## Algoritmi\n",
    "\n",
    "Knjižnica `algorithm` ponuje cel kup uporabnih funkcij, kot so `min`, `max`, `min_element`, `swap`, `count`, ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f515c991-7839-4be1-bacc-1082d9665712",
   "metadata": {},
   "outputs": [],
   "source": [
    "#include <algorithm>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "bc58fc47-9d8e-4f5e-b3c5-1e043d008a22",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "cout << min(5,2) << endl;\n",
    "cout << min({5,3,9}) << endl;\n",
    "\n",
    "vector<int> v={4,7,1,8};\n",
    "cout << *min_element(v.begin(), v.end()) << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68e07c3b-3318-4267-aa0e-6eef307011cb",
   "metadata": {},
   "source": [
    "Verjetno najpogosteje uporabljena funkcija pa je `sort`. Funkcija `sort` sprejme iteratorja na začetek in konec seznama vrednosti, ki jih bo uredila. Tako lahko uporabljamo funkcijo `sort` na različnih strukturah, ki implementirajo pravo vrsto iteratorjev."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fde178a5-d5b0-4801-b2c0-1588c62d85db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 7 8 11 41 \n"
     ]
    }
   ],
   "source": [
    "vector<int> sez = {8,41,11,7,2};\n",
    "sort(sez.begin(), sez.end());\n",
    "for (int x : sez) cout << x << \" \";\n",
    "cout << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fa4369f-8d2d-4930-b579-ec6212c13b7c",
   "metadata": {},
   "source": [
    "### Anonimne funkcije\n",
    "\n",
    "Pogosto pišemo kratke funkcije za enkratno uporabo. Zato večina modernih programskih jezikov (Java, Python, C++, ...) pozna anonimne oz. lambda funkcije. Sintaksa v C++ je `[zunanje spremenljivke](argumenti funkcije) { vsebina }`. Če so zunanje spremenljivke prazne, to pomeni, da lahko vsebina funkcije dostopa samo do svojih argumentov in do globalnih spremenljivk. Vse spremenljivke in argumente lahko funkcija sprejme po vrednosti ali po referenci.\n",
    "\n",
    "V spodnjem primeru bomo ponovno uredili seznam števil, vendar jih bomo tokrat primerjali po abecedi namesto po vrednosti."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "9ad96c74-37c2-4812-bbe2-6b58097f16b4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11 2 41 7 8 \n"
     ]
    }
   ],
   "source": [
    "sort(sez.begin(), sez.end(), [](int a, int b) {\n",
    "    return to_string(a) < to_string(b);\n",
    "});\n",
    "for (int x : sez) cout << x << \" \";\n",
    "cout << endl;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3aa9099-d533-4d16-aa37-d0b65d245acd",
   "metadata": {},
   "source": [
    "## Ostalo\n",
    "\n",
    "C++ seveda ponuja še veliko več. Do tu smo predstavili samo nekaj osnov, ki nam bodo koristile pri reševanju algoritmičnih problemov v nadaljevanju.\n",
    "\n",
    "Kogar zanima več, si lahko na spletu prebere o temah, kot so: razredi (*classes*), predloge (*templates*), pametni kazalci (*smart pointers*), niti (*threads*), izjeme (*exceptions*), preobremenjevanje operatorjev (*operator overloading*), ..."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "C++17",
   "language": "C++17",
   "name": "xcpp17"
  },
  "language_info": {
   "codemirror_mode": "text/x-c++src",
   "file_extension": ".cpp",
   "mimetype": "text/x-c++src",
   "name": "c++",
   "version": "17"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}