๋ชฉ๋ก์ ์ฒด ๊ธ (1099)
KoreanFoodie's Study
AttachedActors vs ChildActors ๋ง์ฝ ๋ค์๊ณผ ๊ฐ์ด ๋ถ๋ชจ ์กํฐ์ ๋ถ์ฐฉ๋ ์กํฐ๋ค์ ์ญ์ ํ๋ ค๊ณ ํ๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น? ๋ง์ฝ ํ์ฌ ์กํฐ์ ์์์ผ๋ก ์ค์ ๋ ActorComponent ๋ค์ ๊ฒฝ์ฐ, ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ก ์กฐํํ ์ ์๋ค. TArray tempChildActors; AActor* owner = GetOwner(); // SomeChildActor->SetOwner(this); ๊ฐ ์ด๋์ ๊ฐ ์คํ๋์๋ค๊ณ ๊ฐ์ owner->GetAllChildActors( tempChildActors, true ); uint32 count = tempChildActors.Num(); ํ์ง๋ง ์์ ๊ฐ์ ๊ฒฝ์ฐ๋, ๋ฌด๊ธฐ๋ฅผ ์บ๋ฆญํฐ์ ์์ผ์ ๋ถ์ฐฉ (AttachToComponent) ํ๋ ๊ฒฝ์ฐ..
์ค๋ธ์ ํธ ์์ฑ ๋ฐ ์ ์ ๋ถ๋ฌ์ค๊ธฐ ์ธ๋ฆฌ์ผ์์ ์ค๋ธ์ ํธ๋ฅผ ์์ฑํ๊ณ ์ ์ ์ ๋ถ๋ฌ์ฌ ๋๋ ๋ณดํต CreateDefaultSubobject ๋ก CDO ๋ฅผ ๋ง๋ค์ด ์ค ๋ค์, ConstructorHelpers::FObjectFinder ๋ก ์ ์ ์ ์ฐ๊ฒฐ์์ผ ์ค๋ค. ์ด ๊ณผ์ ์ ๋จ์ถ์์ผ์ฃผ๋ Helper Function ์ ๋ง๋ค์ด ์ฌ์ฉํด ๋ณด์. CHelpers.h #pragma once #include "CoreMinimal.h" #include "Components/SkeletalMeshComponent.h" #include "Kismet/GameplayStatics.h" #include "Particles/ParticleSystem.h" #include "NiagaraSystem.h" #include "NiagaraFun..
ํ๋ฉด์ ์ถ๋ ฅํ๋ ๋ก๊น ์์คํ ์ฝ์์ ์ถ๋ ฅํ๋ ๊ฒ๊ณผ ๋น์ทํ๊ฒ, ์ด๋ฒ์๋ UE_LOG ๊ฐ ์๋ AddOnScreenDebugMessage ํจ์๋ฅผ ํ์ฉํด ํ๋ฉด์ ๊ฐ์ ์ถ๋ ฅํด๋ณด์. ์ถ์ฒ๋ ์ฌ๊ธฐ! CLog.h class UE_PROJECT_NAME_API CLog { public: static void Print(int32 InValue, int32 InKey = -1, float InDuration = 10, FColor InColor = FColor::Blue); static void Print(float InValue, int32 InKey = -1, float InDuration = 10, FColor InColor = FColor::Blue); static void Print(const FString& I..
์ธ๋ฆฌ์ผ ๋ก๊ทธ ์ธ๋ฆฌ์ผ์ 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๋ฅผ ์ผ๋ฐ์ ์ธ ํฌ์ธํฐ๊ฐ ์๋, ํฌ์ธํฐ..