๋ชฉ๋ก์ ์ฒด ๊ธ (1096)
KoreanFoodie's Study
์ธ๋ฆฌ์ผ ๋ก๊ทธ ์ธ๋ฆฌ์ผ์ UE_LOG ํจ์๋ฅผ ์ด์ฉํ์ฌ ๋ก๊ทธ๋ฅผ ์ถ๋ ฅํ๋ค. ๋จผ์ , .h ํ์ผ์ ์นดํ ๊ณ ๋ฆฌ๋ฅผ ์ ์ธํ๊ณ , ๊ทธ์ ๋ง๋ ์ ์๋ฅผ .cpp ํ์ผ์์ Define ํด์ฃผ๋ฉด ๋๋ค. MyGame.h //General Log DECLARE_LOG_CATEGORY_EXTERN(LogMyGame, Log, All); //Logging during game startup DECLARE_LOG_CATEGORY_EXTERN(LogMyGameInit, Log, All); MyGame.cpp #include "MyGame.h" //General Log DEFINE_LOG_CATEGORY(LogMyGame); //Logging during game startup DEFINE_LOG_CATEGORY(LogMyGameInit); ํค๋..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! ํ์ดํ๋ผ์ด๋ ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๊ฐ ์๋ค๊ณ ํ์. int a = 0; int b = a + 1; a = 1; ์ง๊ด์ ์ผ๋ก๋ b = a + 1 ์ด a = 1 ๋ณด๋ค ๋จผ์ ์คํ๋ ๊ฒ ๊ฐ์ง๋ง, ์ปดํ์ผ๋ฌ๊ฐ ์ด์ ๋ธ๋ฆฌ ์ธ์ด๋ก ๋ฒ์ญํ ๊ฒ์ ๋ณด๋ฉด a = 1 ์ด ๋ ๋จผ์ ์คํ๋๊ธฐ๋ ํ๋ค. ๋ฌผ๋ก b ์ a ์๋ ๊ฐ๊ฐ 1์ด๋ผ๋ ๊ฐ์ด ์ ๋๋ก ๋ค์ด๊ฐ์ง๋ง, ์ปดํ์ผ๋ฌ๋ ์์ ์ ํจ์จ์ฑ์ ์ํด ์ฝ๋์ ์คํ์์๋ฅผ ๋ณ๊ฒฝํ๋ค. ์ด๋ฅผ ํ์ดํ๋ผ์ด๋์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์ด๋ ์ต์ ํ๋ฅผ ์ํด ์ด์ ๋ธ๋ฆฌ ๋ช ๋ น์ด๋ฅผ ํจ์จ์ ์ผ๋ก ๋ฐฐ์นํ๋ ๊ณผ์ ์ ์๋ฏธํ๋ค. ์์ ์์(Modification Order) ๋ช ๋ น์ด๋ฅผ ๋ค์ฃฝ๋ฐ์ฃฝ์ผ๋ก ์คํํ๋๋ฐ๋ ์ด๋ป๊ฒ ์ ๋๋ก..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! Race Condition ์๋ก ๋ค๋ฅธ ์ฐ๋ ๋์์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณต์ ํ ๋ ๋ฐ์ํ๋ ๋ฌธ์ ๋ฅผ ๊ฒฝ์ ์ํ(race condition) ์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค. ๋ค์ ์ฝ๋๋ฅผ ๋ณด์. #include #include #include void worker(int& counter) { for (int i = 0; i < 10000; i++) { counter += 1; } } int main() { int counter = 0; std::vector workers; for (int i = 0; i < 4; i++) { // ๋ ํผ๋ฐ์ค๋ก ์ ๋ฌํ๋ ค๋ฉด ref ํจ์๋ก ๊ฐ์ธ์ผ ํ๋ค (์ง๋ ๊ฐ์ข bind ํจ์ ์ฐธ์กฐ) ..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! ํ๋ก์ธ์ค์ ์ฐ๋ ๋ CPU ์ฝ์ด์์ ๋์๊ฐ๋ ํ๋ก๊ทธ๋จ ๋จ์๋ฅผ ์ฐ๋ ๋(Thread) ๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์ฆ, CPU ์ ์ฝ์ด ํ๋์์๋ ํ ๋ฒ์ ํ ๊ฐ์ ์ฐ๋ ๋์ ๋ช ๋ น์ ์คํ์ํค๊ฒ ๋๋ค. ํ๋ก์ธ์ค๋ ์ฌ๋ฌ ๊ฐ์ ์ฐ๋ ๋๋ก ์ด๋ฃจ์ด์ง๋๋ฐ, ํ๋ก์ธ์ค์ ์ฐ๋ ๋์ ์ฐจ์ด๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณต์ ํ๋๋ ํ์ง ์๋๋์ ์ฐจ์ด์ด๋ค. ๊ฐ ์ฝ์ด์์๋ ์ฝ์ด๊ฐ ๋์๊ฐ๋๋ฐ, ์ปจํ ์คํธ ์ค์์นญ (Context Switching) ์ ํตํด ์ฐ๋ ๋๊ฐ ๋ฒ๊ฐ์๊ฐ๋ฉฐ ์คํ๋๋ค. ๋ณ๋ ฌํ(Parallelizable) ๊ฐ๋ฅํ ์์ ์ฐ๋ ๋๋ฅผ ์ด์ฉํด ๋ณ๋ ฌํ๋ฅผ ์ ์ฉํ๋ฉด ๋์ฑ ๋น ๋ฅธ ์์ ์ด ๊ฐ๋ฅํ ๊ฒฝ์ฐ๊ฐ ์๋ค. ์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ด ํผ๋ณด๋์น ์์ด์ ๊ตฌํ๋..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! Callable Callable ์ด๋, ์ด๋ฆ ๊ทธ๋๋ก ํธ์ถ(Call)ํ ์ ์๋ ๋ชจ๋ ๊ฒ์ ์๋ฏธํ๋ค. ๋ํ์ ์ธ ์์๋ก ํจ์๊ฐ ์๋ค. ํ์ง๋ง C++์์๋ ( ) ๋ฅผ ๋ถ์ฌ ํธ์ถํ ์ ์๋ ๋ชจ๋ ๊ฒ์ Callable ์ด๋ผ๊ณ ์ ์ํ๋ค. #include struct S { void operator()(int a, int b) { std::cout
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! shared_ptr ์ด๋ค ๊ฐ์ฒด์ ๊ฒฝ์ฐ, ์ฌ๋ฌ ํฌ์ธํฐ์์ ์ฐธ์กฐ๋ฅผ ํ์ฌ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ์ด๋, ํด๋น ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๋ ํฌ์ธํฐ์ ์๊ฐ 0์ด ๋์์ ๋ ํด๋น ๊ฐ์ฒด๋ฅผ ๋ฉ๋ชจ๋ฆฌ๋ก๋ถํฐ ํด์ ํด์ฃผ๋ ํฌ์ธํฐ๊ฐ ํ์ํ๋ฐ, ์ด๊ฒ์ด ๋ฐ๋ก shared_ptr์ด๋ค. std::shared_ptr p1(new A()); std::shared_ptr p2(p1); // unique_ptr ์ผ ๊ฒฝ์ฐ ์์ ๊ถ ๋ฌธ์ ๋ก ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค. std::unique_ptr p3(new A()); std::shared_ptr p4(p3); // ์ปดํ์ผ ์ค๋ฅ ์ ์ฌ์ง์ฒ๋ผ, shared_ptr ๋ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํฌ ์ ์๊ณ ..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! Resource Acquisition Is Initialization - RAII ์์์ ํ๋์ ์ด๊ธฐํ๋ค. ์ด๋ ์์ ๊ด๋ฆฌ๋ฅผ ์คํ์ ํ ๋นํ ๊ฐ์ฒด๋ฅผ ํตํด ์ํํ๋ ๊ฒ์ด๋ค. ํจ์ ๋ด๋ถ์์ ์์ธ๊ฐ ๋ฐ์ํด์ ์๋ฉธ์๊ฐ ํธ์ถํ๋ ์ฝ๋์ ๋๋ฌํ์ง ๋ชปํ๋๋ผ๋, ํด๋น ํจ์์ ์คํ์ ์ ์๋์ด ์๋ ๋ชจ๋ ๊ฐ์ฒด๋ค์ ๋น ์ง์์ด ์๋ฉธ์๊ฐ ํธ์ถ๋๋ค(stack unwinding). ๋ง์ฝ ์ด ์๋ฉธ์๋ค ์์ ๋ค ์ฌ์ฉํ ์์์ ํด์ ํ๋ ๋ฃจํด์ ๋ฃ์ผ๋ฉด ์ด๋จ๊น? A* pa = new A(); ์๋ฅผ ๋ค์ด, ์์ ํฌ์ธํฐ pa์ ๊ฒฝ์ฐ, ๊ฐ์ฒด๊ฐ ์๋๋ฏ๋ก ์๋ฉธ์๊ฐ ํธ์ถ๋์ง ์๋๋ค. ๊ทธ ๋์ , pa๋ฅผ ์ผ๋ฐ์ ์ธ ํฌ์ธํฐ๊ฐ ์๋, ํฌ์ธํฐ..
Move ๋ฌธ๋ฒ (Move semantics) Swap function์ ๊ตฌํํด๋ณด์. ์ผ๋ฐ์ ์ธ ํ์ T์ ๋ํ Swap function์ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค. template void swap(const T& a, const T& b) { T tmp(a); a = b; b = tmp; } ์ด ๊ฒฝ์ฐ, T์์ a๋ฅผ ํธ์ถํ๋ ๊ณผ์ ์์ ๋ณต์ฌ ์์ฑ์๊ฐ ํธ์ถ๋๋ค. ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด, ์์ ์ ๊ณตํ๋ move ํจ์๋ฅผ ์ฌ์ฉํ๋ค. template void swap(T& a, T& b) { T tmp = std::move(a); b = std::move(a); a = std::move(tmp); } ์์ ๊ฐ์ ๋ฐฉ์์ผ๋ก swap ํจ์๋ฅผ ๊ตฌํํ๋ฉด, swap์ด ์ค์ ๋ก ํํด์ง๋ ๊ณผ์ ์์ ์ด๋ ์์ฑ์๊ฐ ํธ์ถ๋๋ค. mo..
์ข์ธก๊ฐ๊ณผ ์ฐ์ธก๊ฐ C++์์, ๊ฐ์ ๋์ฒด๋ก ์ฐ์ธก๊ฐ๊ณผ ์ข์ธก๊ฐ์ผ๋ก ๋๋์ด์ง๋ค. (๋ ๊ตฌ์ฒด์ ์ธ ๋ถ๋ฅ๋ ์ด๊ณณ์ ์ฐธ์กฐ) ์ข์ธก๊ฐ์ '์ด๋ฆ'์ ๊ฐ์ง๊ณ ์๋ ๋ ์, ์ฐ์ธก๊ฐ์ '์ด๋ฆ'์ด ์๋ ๋ ์์ด๋ค. ์ด๋ ์์ฑ์์ ์ฐ์ธก๊ฐ ๋ ํผ๋ฐ์ค ํด๋์ค์์ ์์ฑ์๋ฅผ ํธ์ถํ๋ค๊ณ ํด ๋ณด์. ๋ง์ฝ ํด๋์ค๊ฐ String ๋ณ์๊ฐ์ ๊ฐ์ง๊ณ ์๋ค๋ฉด, ์ด๋ฏธ ์์ฑ๋ ๋ณ์ a๋ฅผ ์ด์ฉํด b๋ฅผ ๋ง๋ ๋ค๊ณ ํ ๋ String ๊ฐ์ ๋งค๋ฒ ์๋ก ์์ฑํ๋ ๊ฒ์ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น์ด๋ค. ์๋ก์ด String์ ๋ด์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ ๋์ , ํฌ์ธํฐ๋ฅผ ์ ๋ฌํจ์ผ๋ก์จ ํจ์จ์ ์ผ๋ก ๊ฐ์ ์ฎ๊ธฐ๋ฉฐ ํด๋์ค ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋๋ฐ, ์ด๋ ์ด๋ ์์ฑ์๋ฅผ ์ฌ์ฉํ๋ค. ์ด๋ ์์ฑ์๋ ์๋์ ๊ฐ์ ํ์์ ๊ฐ์ง๋ค. ์ฐ์ธก๊ฐ ๋ ํผ๋ฐ์ค์ ๊ฒฝ์ฐ, typename && var ๊ฐ์ ํ์์ผ๋ก ํํ๋๋๋ฐ, ์ด๋ &..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! throw ๋ก ์์ธ ๋ฐ์์ํค๊ธฐ ์์ธ๋ฅผ ๋ฐ์์ํค๋ ์์ ์ฝ๋๋ฅผ ๋ณด์. // ์๋ต ... const T& at(size_t index) const { if (index >= size) { // ์์ธ๋ฅผ ๋ฐ์์ํจ๋ค! throw std::out_of_range("vector ์ index ๊ฐ ๋ฒ์๋ฅผ ์ด๊ณผํ์์ต๋๋ค."); } return data[index]; } ์์์๋ ๋ฒ์ ์ด๊ณผ๋ฅผ ์๋ฆฌ๋ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๋ค. C++ ๋ ์์ธ๋ฅผ ๋์ง๊ณ ์ถ๋ค๋ฉด throw ๋ก ์์ธ๋ก ์ ๋ฌํ๊ณ ์ถ์ ๊ฐ์ฒด๋ฅผ ์จ์ฃผ๋ฉด ๋๋ค. C++ ํ์ค์๋ overflow_error, length_error, runtime_error ..