pridani poznamek s conteinery, restrukturalizace, oprava kodu

pridani poznamek ke containerum zatim pouze s vectory
poznamky z hodim maji ted vlastni podslozku
lehka oprava kodu vsede mozne, hlavne pridani cpp pro lepsi cteni a
oprava drobnych chybek

Containery (vector, list, map).md

@@ -0,0 +1,161 @@
+# Vector
+- [geegs for geegs](https://www.geeksforgeeks.org/cpp/vector-of-strings-in-cpp/) - to jsem prakticky vykradl
+- **vlastně třída, která je implementací dynamického pole**
+- Proč se to jmenuje vector? Protože to autor standardní knihovny (Alex Stepanov) prostě nešikovně pojmenoval
+> "One could argue that valarray should have been called vector because it is a traditional mathematical vector and that vector should have been called array. However, this is not the way the terminology evolved." - Bjarne Stroustrup (autor jazyka)
+
+Vektory mají svoje funkce, které umožňují základní operace s polem typu: přidání prvku na začátek a na konec, přidání prvku na n-tou pozici, přepsaní a přístup, mazání prvků...
+## Inicializace
+Syntax: `vector<typ_polezek> v1;`
+Příklad inicializace:
+```cpp
+#include <iostream>
+#include <vector>
+
+int main(void)
+{
+	vector<int> v1; //neinicializovaný vektor
+	vector<int> v2 = {1, 2, 3}; //vekor s prvky 1 2 3
+	vectro<int> v3(8, 42); //vektor o 8 prvcích o hodnotě 42
+
+	vector<char> v4 = {'f', 's', 'o', 'c', 'i', 'e', 't', 'y'};
+	vector<string> v5 =
+	{
+		"Do not go gentle into that good night,",
+		"Old age should burn and rave at close of day;",
+		"Rage, rage against the dying of the light."
+	};
+	vector<nejaka_trida> v6;
+	
+return 0;
+}
+
+```
+
+## begin(), end(), empty()
+- `begin()` a `end()` jsou to funkce vektoru, které vrací iterátory na první a poslední hodnotu.
+- Když je vector prázdny platí: `v.begin() == v.end()`. To můžeme taky poznat pomocí funkce `v.end()`.
+- `v.end()` vždy ukazuje **na prázdnou hodnotu za posledním prvkem vektoru**, kam lze bezstarostně zapisovat další prvek, když třeba.
+
+## Přidání prvku
+- máme funkce `v.push_back()` a `v.insert()`
+- `v.push_back(hodnota)` přidá hodnotu na konec vektoru
+- Funkce `v.insert()` přidává hodnotu/hodnoty na n-tý prvek a má několik různých možností zápisu:
+```cpp
+#include <iostream>
+#include <vector>
+using namespace std;
+
+int main(void)
+{
+	//prazdny koncert
+    vector<string> koncert;
+    //pridani prvniho prvku na konec pomoci push_back
+	koncert.push_back("prvni pisnicka");
+	//pridani prvku na posledni pozici
+	koncert.insert(koncert.end(), "lidi jdou pít do klubu")
+	//pridani 3 prvku na 1. pozici (tedy prvek na posledni pozici se posune o 3)
+	koncert.insert(koncert.begin() + 1, 3, "opravdu posledni pisnicka");
+	
+	for (string udalost : koncert)
+	{
+		cout << udalost << endl;
+	}
+	
+return 0;
+}
+
+//VYPIS:
+//prvni pisnicka
+//opravdu posledni pisnicka
+//opravdu posledni pisnicka
+//opravdu posledni pisnicka
+//lidi jdou pít do klubu
+```
+
+Možnosti `insert`:
+```cpp
+vector<int> a;
+vector<int> b;
+a.insert(pozice a, hodnota);
+a.insert(pozice a, pocet_prvku, hodnota);
+a.insert(pozice a, poc_poz_jineho_vek, konc_pozice_jin_vek);
+
+//přepíše vektor b na začátek vektoru a
+a.insert(a.begin(), b.begin(), b.(end))
+```
+
+## Přístup k prvkům a změna
+- v podstatě mám 2 možnosti a to `v[i]` nebo `v.at(i)`
+- Fungují stejně akorát `v.at()` vyhodí výjimku při pokusu přistupovat mimo pole a je nepatrně pomalejší
+- výjimka je `std::out_of_range`
+
+```cpp
+#include <iosteam>
+#include <vector>
+using namespace std;
+
+int main(void)
+{
+	vector<string> v = {"Ronald", "Artiom", "Chang", "Waldo"};
+	cout << v[0] << endl;
+	cout << v.at(3) << endl;
+	//cout << v.at(4) << endl; //vyhodí výjimku out of range
+	
+	//zmena jmen
+	v[1] = "Mercedes";
+	v.at(2) = "Anička";
+	//v.at(7) = "Pavla"; //vyhodi vyjimku
+	
+	return 0;
+}
+```
+
+## size a využití
+- `v.size()` vrací počet prvků
+
+```cpp
+#include <iosteam>
+#include <vector>
+using namespace std;
+
+int main(void)
+{
+	vector<string> v = {"Ronald", "Artiom", "Chang", "Waldo"};
+	cout << v.size() << endl; //vypíše 4
+	
+	for (int i = 0; i < v.size(); i++)
+    {cout << v[i] << " ";} //vypíše všechny jména vedle sebe
+    return 0;
+}
+```
+
+## Mázaní prvků
+- mám 2 možnosti a to `v.pop_back()` a `v.erase()`
+- `v.pop_back()` vymaže poslední prvek z vektoru
+- `v.erase()` vymaže n-tý prvek a posune celý vektor. Potřebuje knihovnu `<algorithm>`
+```cpp
+#include <iostream>
+#include <vector>
+#include <algorithm>
+using namespace std;
+
+int main() {
+    vector<char> v = {1, 2, 8, 4, 0};
+
+  	v.pop_back(); //vymaže 0
+  	v.erase(v.begin()); // vymaže 1
+  	v.erase(find(v.begin(), v.end(), 8)); //najde a vymaže 8
+
+  	
+  	for (int i = 0; i < v.size(); i++) {
+        cout << v[i] << " ";
+    } //zbyde 2,4
+    return 0;
+}
+```
+# List
+
+# Map
+
+# Unordered_map

poznamky z hodin/Cviceni 2.md

@@ -0,0 +1,53 @@
+- 26. 2 - čtvrtek 11:00
+
+- dnes: třídy a objekty, public/protected/private, constructor/destructor
+
+# Konstruktory
+- můžu přetěžovat, ale **POZOR**:
+
+```
+    TridaA(void) //constructor pro inicializaci promenne
+    {
+      this->a = 0;
+      this->b = 0;
+      this->c = 0;
+      std::cout << "Byl zavolan konstruktor bez arg." << std::endl;
+    }
+
+    TridaA(int a) //inicializace z argumentu constructoru
+    {
+      this->a = a;
+      this->b = 0;
+      this->c = 0;
+      std::cout << "Byl zavolan konstruktor s arg." << std::endl;
+    }
+    
+    TridaA(int a, int b = 42, int c = 64)
+    {
+      this->a = a;
+      this->b = b;
+      this->c = c;
+    }
+```
+
+Chyby kompilatoru:
+```
+main.cpp: In function ‘int main()’:
+main.cpp:44:16: error: call of overloaded ‘TridaA(int)’ is ambiguous
+   44 |   TridaA obj1(1); //inicializujeme objekt
+      |                ^
+main.cpp:44:16: note: there are 4 candidates
+main.cpp:31:5: note: candidate 1: ‘TridaA::TridaA(int, int, int)’
+   31 |     TridaA(int a, int b = 42, int c = 64)
+      |     ^~~~~~
+main.cpp:23:5: note: candidate 2: ‘TridaA::TridaA(int)’
+   23 |     TridaA(int a) //inicializace z argumentu constructoru
+      |     ^~~~~~
+main.cpp:3:7: note: candidate 3: ‘constexpr TridaA::TridaA(const TridaA&)’
+    3 | class TridaA
+      |       ^~~~~~
+main.cpp:3:7: note: candidate 4: ‘constexpr TridaA::TridaA(TridaA&&)’
+
+```
+
+- **MUSÍ TO BÝT JEDNOZNAČNÉ:**