[C++] ๋๋ค(lambda) ํจ์
๋๋ค๋ ์ต๋ช ํจ์๋ ๋ฌด๋ช ํจ์๋ผ๊ณ ๋ ๋ถ๋ฅด๋ ๊ธฐ๋ฅ์ผ๋ก, C++11๋ถํฐ ํ์ค์ ์ถ๊ฐ๋์๊ณ C++14์์ ํ ์ฐจ๋ก์ ๊ฐ์ ์ด ์ด๋ฃจ์ด์ก๋ค.
๋๋คํจ์์ ์ญํ ์ ์งง๊ณ ์ด๋ ต๊ฒ ๋งํ๋ฉด 'ํด๋ก์ ๊ฐ์ฒด๋ฅผ ์์ฑ'ํ๋ ๊ฒ์ด๋ผ๊ณ ํ ์ ์๋ค.
๊ทผ๋ฐ ๋ญ ์ฌ์ค ์ด๋ ค์ธ๊ฑด ์๊ณ ๊ทธ๋ฅ ํจ์ ์ค์ฝํ ๋ด์์ ํจ์๋ฅผ ์ ์ํ๊ณ ๊ทธ ํจ์์ ํฌ์ธํฐ๋ฅผ ์ป์ด๋ผ ์ ์๋ ๊ฒ์ด๋ผ๊ณ ๋ณด๋ฉด ๋๋ค.
๋๋ต์ ์ธ ํํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
[ capture ] { expression } //ํ๋ผ๋ฏธํฐ ์์๊ฒฝ์ฐ
or
[ capture ] ( parameter ) { expression }
or
[ capture ] ( parameter ) ->return-type { expressiom }
์บก์ณ๋ ์ผ๋จ ๋ค๋ก ๋ฏธ๋ฃจ๊ณ ,
ํ๋ผ๋ฏธํฐ๋ ํต์ ํจ์์ ํ๋ผ๋ฏธํฐ์ ์์ ํ ๋์ผํ๋ค.
C++14๋ถํฐ๋ ๋งค๊ฐ๋ณ์์ auto๋ฅผ ์ธ์์๋ค.(์ ๋ค๋ฆญ ๋๋ค. ํจ์ํ ํ๋ฆฟ๊ณผ ์ ์ฌํ๋ค.)
ํจ์ ๋ชธํต๋ ํต์ ํจ์์ ํฐ ์ฐจ์ด๋ ์๋ค. ๊ทธ๋ฐ๋ฐ C++11์์๋ ๋ชธํต ์์์์ ์ง์ญ๋ณ์ ์ ์ธ์ด ๋ถ๊ฐํ์ง๋ง C++14์์๋ ํ์ฉ๋๋ค.
๋ฐํํ์ ์ ์จ์ค๋ ๋๊ณ , ์์จ์ค๋ ๋๋ค. ๋ํดํธ๋ก ๋ ๊ฒฝ์ฐ ์ปดํ์ผ๋ฌ๊ฐ ์์์ ์ถ๋ก ํด์ค๋ค.
์บก์ณ๋ ์ธ๋ถ์ ์กด์ฌํ๋ ๊ฐ์ ๊ฐ์ ธ๋ค ์ธ์ ์๋ ๊ธฐ๋ฅ์ด๋ค. ๊ฐ๋ฌด๋ฆฌ๋ ํ๋์ด๋ผ๊ณ ๋ ๋ถ๋ฅธ๋ค.
๋๋คํจ์ ์ธ๋ถ์ ์๋ var์ ๋ํด,
[var], [var,var2]... ์ด๋ฐ์์ผ๋ก ํ๋ฉด ๊ฐ ์ ๋ฌ์ด๋ผ๊ณ ํด์ ๋๋ค ๋ด์์๋ ๋ณ๊ฒฝ์ด ๋ถ๊ฐํ๋ค.
[&var] ์ด๊ฑด ์ฐธ์กฐ ์ ๊ทผ์ด๋ค. ๋๋ค ๋ด์์ ๊ฐ ๋ณ๊ฒฝ์ด ๊ฐ๋ฅํ๋ค.
[=] ์ธ๋ถ์ ์๋ ๋ชจ๋ ๊ฐ์ ๊ฐ์ผ๋ก ์ ๊ทผํ๋ค.
[&] ๋ชจ๋ ๊ฐ์ ์ฐธ์กฐ๋ก ์ ๊ทผํ๋ค.
๊ทธ๋ฆฌ๊ณ C++14๋ถํฐ๋ ์ด๊ธฐํ ์บก์ณ๋ผ๊ณ
[num=5+7] ์ด๋ฐ์์ผ๋ก ๋๋ค ๋ด์์ ์ธ ๋ณ์๋ฅผ ์ ์ธํ ์ ์๋ค.
๊ทธ๋ฅ ๋ณ์๋ช
๋ง ๋ถ์ด๋ ์ผ๋ฐ ์บก์ณ์ ๋ค๋ฅด๊ฒ ๊ฑฐ์ ๋ชจ๋ ํํ์์ ๋ค ๋ฃ์ ์๊ฐ ์๋ค.
๋ฌด๋ธ์๋งจํฑ๋ ๊ฐ๋ฅํ๋ค. ์ด๊ฑธ ์์ฉํด์ ์ด๋ํด๋ก์ ธ๋ฅผ ๊ตฌํํ ์ ์๋ค.
[hmm = std::move(some)](){...};
๋๋ค๋ ์ผ๋ฐํจ์์ฒ๋ผ ์ฌ๊ทํธ์ถ์ด ๊ฐ๋ฅํ๋ค. ๊ทผ๋ฐ ๊ตณ์ด...?
์ ๊ทธ๋ผ ์ด์ ๋๋ค๋ฅผ ์จ๋ณด์.
int main()...
[] (int n) { std::cout<<n<<std::endl; };
...
์ด๋ฌ๋ฉด ๋๋คํจ์๊ฐ ์์ฑ๋๋ค.
๊ทผ๋ฐ ์ด๋ฌ๊ณ ๋ฐ๋ก ์ปดํ์ผํ๋ฉด ์๋ฌด๊ฒ๋ ์ถ๋ ฅ๋์ง๊ฐ ์๋๋ค.
๊ทธ๋ฅ ํจ์๋ง ๋ง๋ค์ด๋๊ณ ์๋ฌด๊ฒ๋ ์ํ๊ธฐ๋๋ฌธ์ ๋๋ค์ ์ฃผ์๊ฐ์ด ์์ฑ๋๋ค๊ฐ ๋ถ ๋ ๋ฒ๋ฆฌ๋ ๊ฒ์ด๋ค.
[] (int n) { std::cout<<n<<std::endl; } (10);
์ด๋ฌ๋ฉด 10์ด ์ถ๋ ฅ๋ ๊ฒ์ด๋ค. ๋๋ค๋ ํจ์์ด๊ธฐ ๋๋ฌธ์ ๋ฐ๋ก ๊ฐ 10์ ์ ๋ฌํด์ ํธ์ถํ๋ ๊ฒ์ด๋ค.
๊ทธ๋ฆฌ๊ณ ํจ์ํฌ์ธํฐ์ ์ ์ฅํด์ ์ฐ๋ ๋ฐฉ๋ฒ์ด ์๋ค.
auto Func = [] (int n)
{ std::cout<<n<<std::endl; };
ํจ์ํฌ์ธํฐ๋ ํ์ ๋ํค๋์ std::function์ ์ ์ฅํ ์๋ ์๊ฒ ์ง๋ง, ๋ง์ด์ด์ค ํ๋์ ๊ธ์ ๋ฐ๋ฅด๋ฉด function์ auto๋ก ์ถ๋ก ํด์ ์ฐ๋ ๊ฒ๋ณด๋ค ์ฑ๋ฅ์ด ํ๋ฌ๋ฆฌ๊ณ ํ์ดํํ๊ธฐ๋ ๋นก์ธ๊ธฐ ๋๋ฌธ์ ์์ฐ๋๊ฒ ๋ซ๋ค๊ณ ํ๋ค.
์ด์จ๋ ์ ๋ฌ๋ฉด ์ด๋ ๊ฒ
Func(10);
ํจ์์ ๊ฐ์ด ์ฌ์ฉํ ์๊ฐ ์๋ค.
๊ทผ๋ฐ ์ด๊ฒ๋ง์ผ๋ก๋ ์ด๋ฐ ๊ธฐ๋ฅ์ด ๊ตณ์ด ํ์ํ๊ฐ? ํ๋ ์์ฌ์ด ๋ค ์ ์์ ๊ฒ์ด๋ค.
๋๋ค์ ์ง๊ฐ๋ ํจ์ ๊ฐ์ฒด ํํฐ(Functor)๊ฐ ์ฌ์ฉ๋ ๋ ๋๋ฌ๋๋ค.
algorithm ํค๋์ for_each ํจ์๋ฅผ ์ด์ฉํด์ ๋ฒกํฐ ์ปจํ
์ด๋์ ๋ฉค๋ฒ๋ฅผ ์ ๋ถ ์ถ๋ ฅํ๋ ์ฝ๋๋ฅผ ์ง ๋ค๊ณ ์น์.
for_each๋ ์์ ์์น ์ดํฐ๋ ์ดํฐ์ ๋ ์์น ์ดํฐ๋ ์ดํฐ๋ฅผ ๋ฐ์์ ๋ฒ์๋ฅผ ์ง์ ํ๊ณ , ํจ์ ๊ฐ์ฒด๋ฅผ ๋ง์ง๋ง ์ธ์๋ก ๋ฐ์์ ๊ฐ๊ฐ ๋ฉค๋ฒ๋ฅผ ํจ์๊ฐ์ฒด์ ๋ฐฉ์๋๋ก ์ ๊ทผํ๊ฒ ํด์ฃผ๋ ํจ์๋ค.
class Functor
{...};
int main()
{
ย ย ย ......
ย ย ย vector
[for_each(v_arr.begin](http://for_each(v_arr.begin)(), v_arr.end(), Functor() );
}
๋๋ค๊ฐ ๋ฑ์ฅํ๊ธฐ ์ ์๋ ๋ค ์ด๋ฐ์์ผ๋ก ์ผ์๋ค.
for_each์ ์ธ๋ฒ์งธ ์ธ์๋ก ํจ์์ ํฌ์ธํฐ๋ฅผ ๋ฃ์ด๋ ๋์ง๋ง ํจ์๊ฐ์ฒด๊ฐ ์ฑ๋ฅ์ด ๋ ์ข๋ค๊ณ ํ๋๋ผ.
์, ์ด ์ฝ๋์ ๋ฌธ์ ์ ์ด ๋ฌด์์ผ๊น
๋ถ๋ช
์ ์์ ์ผ๋ก ์๋ํ๊ณ ๋ฑํ ๋ฌธ์ ๋๋ ๊ฑด ์์ด๋ณด์ธ๋ค.
๊ฐ๋
์ฑ์๋ ๋ฌธ์ ๊ฐ ๋ฑํ ์๋ค.
๊ทธ๋ฐ๋ฐ, ์ ํจ์๊ฐ์ฒด์ ์ ์๋ถ์ ํจ์๊ฐ์ฒด ํธ์ถ๋ถ ์ฌ์ด์ ํ ์์ญ์๋ฐฑ์ค์ ์ฝ๋๊ฐ ๋ฐํ์๋ค๊ณ ์๊ฐํด๋ณด์, ์๋๋ฉด ํจ์๊ฐ์ฒด๊ฐ ์์ ๋ค๋ฅธ ํ์ผ์ ๋ถํ ์์ฑ๋์์ ์๋ ์๋ค.
๊ทธ๋ฌ๋ฉด ํด๋น ํจ์๊ฐ์ฒด๊ฐ ํธ์ถ๋๋ ๋ถ๋ถ์ ๋ณด๊ณ ์ดํดํ๊ฑฐ๋ ๊ณ ์น๋ ค๋ฉด ๊ทธ๋๋ง๋ค ํจ์๊ฐ์ฒด ์ ์๋ถ๋ก ์ด๋ํ๊ฑฐ๋ ํผํนํด์ ํ์ธ์ ํด์ผํ๋ค.
๋ณ๊ฑฐ ์๋๊ฒ๊ฐ์ง๋ง ์ด๋ฐ๊ฒ ์์ด๊ณ ์์ด๋ค๋ณด๋ฉด ํฐ ๋ถํธ์์๊ฐ ๋๊ณ ๊ฐ๋
์ฑ์ด ๋๋น ์ง๋ค๊ณ ํ ์ ์๋ค.
ํ์ง๋ง ๋๋ค๋ฅผ ์ฌ์ฉํ๋ฉด ์ด๋ฌํ ๋ฌธ์ ์ ์ ์ ๊ฑฐํ ์ ์๋ค.
[for_each(v_arr.begin](http://for_each(v_arr.begin)(), v_arr.end(), [] (int n) { std::cout<<n<<std::endl; } );
์คํฌ๋กค ์ฌ๋ฆฌ๊ฑฐ๋ ํผํนํ ๊ฑฐ ์์ด, ๋ฐ๋ก ๋์ ๋ฑ ๋ค์ด์จ๋ค.
์ด๊ฒ ๋ฐ๋ก ๋๋ค๋ค.