# 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
```