74 lines
2.8 KiB
Markdown
74 lines
2.8 KiB
Markdown
# 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)
|
|
|
|
|
|
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
|
|
``` |