vypracovani temat z 3. prednasky

Funktory a Lambda funkce.md

@@ -0,0 +1,74 @@
+# Funktory
+Jsem línej to víc rozepsat... pozn. pro sebe dodělat funktory potom. Teď mám přibližné vysvětlení v Přetěžování operátorů.
+Prostě to je objekt, co se chová jako funkce, ale je uložený jako objekt (jako proměnná) v kódu a může mít vnitřní funkce a proměnné. Užitečné to je třeba když chci funkci, co si umí pamatovat data z každého zavolání (třeba sčítá všechny čísla, co do ní jsou poslány jako argumenty).
+# Lambda funkce
+- lambda funkce jsou primárně způsob, jak zjednodušit zápis funktoru.
+- [lambda gfg](https://www.geeksforgeeks.org/cpp/lambda-expression-in-c/)
+- [lambda capture gfg](https://www.geeksforgeeks.org/cpp/lambda-capture-clause-in-cpp/)
+
+Lambdy jsou divný... ale užitečný. Jde o to, že někdy chci mít možnost napsat hodně rychlou funkci, bez toho, abych ji někde musel definovat. Vytvořím tedy vlastně funkci do proměnné, a využiji ji přímo na místě a pak ji třeba hned zahodím.
+
+Syntax:
+```cpp
+[](int a, int b) {return a + b;}
+```
+což je `[capture](parametry) -> návratový_typ { tělo }` ale hodně je optional... (třeba capture)
+![obrzazek gfg](https://media.geeksforgeeks.org/wp-content/uploads/20260123115647200091/lambda_expression_in_c_.webp)
+
+Příklad: Řekněme, že si někde potřebuju nutně definovat sčítání (protože mám hloupý cpp a zapomnělo to, nebo idk :(   )
+```cpp
+auto add = [](int a, int b) {return a + b;};
+
+int x = add(3,4);
+```
+
+Mám zde funkci, co je vlastně "uložená v proměnné". Ve skutečnosti je to ale jenom **funktor** tedy alternativa pro:
+```cpp
+class __Lambda123
+{
+public:
+    int operator()(int x, int y)
+    const {
+        return x + y;
+    }
+};
+
+__Lambda123 add;
+```
+
+**Lambda funkce  se musí ukládat do proměnných typu `auto`!!
+
+Co je *capture*?
+Lambda funkce umožňuje přijmout hodnoty/proměnné z lokálního bloku a dále s nimi pracovat jako s vlastními proměnnými.
+Mám 2 typy *capture* a to *capture by reference* a *capture by value*. Jedno mi umožňuje vzít referenci k proměnným/objektům a v lambdě je měnit. Druhé mi umožňuje hodnoty do lambdy prostě zkopírovat.
+
+Př: (ukradeno z geeks for geeks)
+```cpp
+int main() {
+    vector<int> vec1 = {10, 20, 30, 40, 50}; //vektory jsou jako pole
+    vector<int> vec2 = {1, 2, 3, 4, 5};
+    
+    auto lambda = [&vec1, vec2]() //& je ref. a druhé je pouze hodnota
+    {
+        for (int& num : vec1) {num *= 10;}
+        for (int num : vec2) {cout << num * 10 << " ";}
+        cout << endl;
+    };
+    
+    lambda();
+    
+    cout << "Vector 1: ";
+    for (int num : vec1) cout << num << " ";
+    
+    cout << "\nVector 2: ";
+    for (int num : vec2) cout << num << " ";
+    
+    return 0;
+}
+```
+
+Další možnosti:
+```cpp
+auto lambda1 = [&](int x){}; //VŠECHNY externí proměnné jako refernec
+auto lambda2 = [=](int x){}; //VŠECHNY externí proměnné jako hodnotu
+```