Lambda function

ํ•จ์ˆ˜ ์•ˆ์—์„œ ๋ถ€๋ฅผ ์ˆ˜ ์žˆ๋Š”ย Local function! ์‚ฌ์‹ค ์ •์ฒด๋Š” ๊ฐ์ฒด์ด์ง€๋งŒ, ์šฐ๋ฆฌ๋Š” ํ•จ์ˆ˜์˜ ๊ฐœ๋…์œผ๋กœ ๊ฐ–๋‹ค ์“ด๋‹ค!

Usage

[closure](์ž…๋ ฅ ๋งค๊ฐœ๋ณ€์ˆ˜)->์ถœ๋ ฅ type{๋‚ด์šฉ}

Local function ์ด๊ธฐ ๋•Œ๋ฌธ์— ๋งŒ๋“ค์–ด์กŒ๋‹ค๊ฐ€ ๋ฆฌํ„ด ํ›„ ์‚ฌ๋ผ์ง„๋‹ค.

Example

#include <iostream>
#include <vector>
#include <functional>
 
using namespace std;
 
int evaluate(int(*func)(int, int), int x, int y){
 
    return func(x, y);
}
 
int main(){
    // sum: [](int x, int y)->int{return x + y;}
    cout << evaluate([](int x, int y)->int{return x + y;}, 2, 3) << endl;
 
    // mult: [](int x, int y)->int{return x*y;}
    // mult: [](int x, int y){return x*y;} ๊ตณ์ด ์•ˆ์ ์–ด๋„๋ผ ๋„ˆ๋ฌด ๋ช…ํ™•ํ•ด์„œ
    cout << evaluate([](int x, int y){return x * y;}, 2, 3) << endl;
 
    // lambda ํ•จ์ˆ˜๋ฅผ ๋ฐ”๋กœ ์ƒ์„ฑํ•ด์„œ ํ˜ธ์ถœ
    [](int x, int y){cout << x << ", " << y << endl;}(2,3);
 
    auto f  = [](int x, int y)->int{return x - y;};
    cout << f(3, 5) << endl;
 
}

evaluateย ํ•จ์ˆ˜๋Š” ํ•จ์ˆ˜ ํฌ์ธํ„ฐ์™€, ์ธ์ž ๋‘๊ฐœ๋ฅผ ๋ฐ›์•„, ํ•ด๋‹นํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ๋ฆฌํ„ดํ•ด์ฃผ๋Š” ํ•จ์ˆ˜์ด๋‹ค. mainย ํ•จ์ˆ˜ ๋‚ด์—์„œ ์ฆ‰์„์œผ๋กœ ๋‚ด๊ฐ€ ์›ํ•˜๋Š” ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค๊ณ , evaluateย ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด Lambda function ์„ ์‚ฌ์šฉํ•˜๋ฉด ๋œ๋‹ค!

closure

์šฐ๋ฆฌ๊ฐ€ ๊ธฐ์กด์— ํ•จ์ˆ˜๋ฅผ ๋งŒ๋“ค ๋•Œ, ๋žŒ๋‹ค ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•  ๋•Œ ์šฐ๋ฆฌ๋Š” ์ด๊ฑธ ํ•จ์ˆ˜์ฒ˜๋Ÿผ ์‚ฌ์šฉํ•œ๋‹ค. ์ฆ‰, ์ž…๋ ฅ ํŒŒ๋ผ๋ฏธํ„ฐ๋ฅผ ์ œ์™ธํ•˜๊ณ ๋Š” ํ•จ์ˆ˜์˜ ๊ตฌํ˜„๋ถ€์—์„œ ๋‹ค๋ฅธ ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์—†์—ˆ๋‹ค.

ํ•˜์ง€๋งŒ ๋žŒ๋‹คํ•จ์ˆ˜์˜ ๊ฒฝ์šฐ, ์ž…๋ ฅ ํŒŒ๋ผ๋ฏธํ„ฐ์ด์™ธ์˜ ๋ณ€์ˆ˜๋ฅผ ์ฝ์–ด์˜ฌ ์ˆ˜ ์žˆ๋‹ค.

๋žŒ๋‹ค ํ•จ์ˆ˜๊ฐ€ ํŠน์ • ํ•จ์ˆ˜์˜ย ์ง€์—ญ ํ•จ์ˆ˜ย ์ฒ˜๋Ÿผ ์‚ฌ์šฉ๋˜๊ธฐ ๋•Œ๋ฌธ์ธ๋ฐ, ๋žŒ๋‹คํ•จ์ˆ˜๊ฐ€ ์†ํ•ด์žˆ๋Š” ํ•จ์ˆ˜์˜ ๋ณ€์ˆ˜๋ฅผ ๊ฐ€์ ธ์™€ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

์ด ์  ๋•Œ๋ฌธ์—, ๊ธ€์˜ ๋„์ž…๋ถ€์—์„œ ๋žŒ๋‹คํ•จ์ˆ˜์˜ ์ •์ฒด๋Š” ๊ฐ์ฒด๋ผ๊ณ  ํ–ˆ๋˜ ๊ฒƒ์ด๋‹ค! ํ•จ์ˆ˜์˜ ๋ชจ์–‘์„ ํ•˜๊ณ  ์žˆ์ง€๋งŒ, ํด๋ž˜์Šค ๊ตฌ์„ฑ์ด ๊ฐ์ฒด์ฒ˜๋Ÿผ ๋˜์–ด ์žˆ๋‹ค.(๋‡Œํ”ผ์…œ)

์‚ฌ์šฉ์˜ˆ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™๋‹ค.

int evaluate(int(*func)(int, int), int x, int y){
    return func(x, y);
}
 
int main(){
    int a;
    cin >> a;
    // [](int x, int y){return x*y;}
 
    // [closure]: capturing variables
    // [] ์•ˆ์— ๋ณ€์ˆ˜๋ฅผ ๋„ฃ์œผ๋ฉด ์ด ๋žŒ๋‹ค ํ•จ์ˆ˜๋‚ด์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
    // ์›๋ž˜๋Š” ์ธํ’‹ํŒŒ๋ผ๋ฏธํ„ฐ๋งŒ ์‚ฌ์šฉ๊ฐ€๋Šฅํ–ˆ๋Š”๋ฐ , ์™ธ๋ถ€ ๋ณ€์ˆ˜๋ฅผ ๊ฐ€์ ธ์˜ฌ ์ˆ˜ ์žˆ๋‹ค๋Š” ๊ฒƒ
    // [a] : ๋ณ€์ˆ˜ a๋ฅผ call by value ๋กœ ํ•จ์ˆ˜์— ์ „๋‹ฌ
    // [&a] : ๋ณ€์ˆ˜ a๋ฅผ call by reference๋กœ ํ•จ์ˆ˜์— ์ „๋‹ฌ
    // [=]: ๋ชจ๋“  ์ฃผ์œ„ ๋ณ€์ˆ˜๋ฅผ call by value๋กœ ํ•จ์ˆ˜์— ์ „๋‹ฌ
    // [&]: ๋ชจ๋“  ์ฃผ์šฐ ๋ณ€์ˆ˜๋ฅผ call by reference๋กœ ํ•จ์ˆ˜์— ์ „๋‹ฌ
 
    cout << evaluate([a](int x, int y){return a*x*y;}, 2, 3) << endl;
 
    return 0;
}
 

Function Object

์šฐ๋ฆฌ๊ฐ€ ์œ„์—์„œ ๊ตฌํ˜„ํ•œย evaluateย ํ•จ์ˆ˜์—์„œ, ํ•จ์ˆ˜ ํฌ์ธํ„ฐ๋กœ ์ฒซ๋ฒˆ์งธ ์ธ์ž๋ฅผ ์ฃผ์—ˆ๋‹ค.

๊ทธ๋Ÿฐ๋ฐ, ํฌ์ธํ„ฐ๋ฅผ ์‚ฌ์šฉํ•ด์„œ ๋‚˜ํƒ€๋‚ด๋Š” ๊ฒƒ์€ ์œ„ํ—˜ํ•˜๋ฏ€๋กœ, ์šฐ๋ฆฌ๋Š” ์ด๊ฒƒ์„ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๊ฐ์ฒด๋ฅผ ๋งŒ๋“ค์–ด ๊ด€๋ฆฌํ•˜๋Š” ๊ฒƒ์ด ๋ณด๋‹ค ์•ˆ์ „ํ•˜๋‹ค.

์ด ๊ฒƒ์„ ๊ฐ€๋Šฅํ•˜๊ฒŒ ํ•˜๋Š” ๊ฐ์ฒด๊ฐ€ย functionย ์ด๋‹ค.

function<์ถœ๋ ฅ์ž๋ฃŒํ˜•<์ž…๋ ฅ์ž๋ฃŒํ˜•1, ์ž…๋ ฅ์ž๋ฃŒํ˜•2...>ํ•จ์ˆ˜ ์ด๋ฆ„

Usage

int evaluate2(function<int(int, int)>func , int x, int y){
    return func(x, y);
}