deulee의 개발 노트

원티드 포텐업 게임 클라이언트 지원

deulee — Wed, 9 Oct 2024 22:52:19 +0900

안녕하세요, 저는 언리얼 엔진을 이용해 게임 개발을 진행하며 주로 네트워크 부분을 담당하고 있습니다. 엔진 코드를 분석하고 디버깅하면서 독학으로 실력을 쌓아왔지만, 실무에서 올바른 접근을 하고 있는지에 대한 확신이 부족해 고민이 많았습니다. 특히 네트워크 최적화, 멀티플레이 기능 구현, 타이밍 오류 해결에 적합한 설계를 하고 있는지에 대해 피드백을 받을 기회가 부족했습니다. 또한, 체계적인 게임 개발 프로세스를 배우고 적용할 기회가 부족해 어려움을 겪은 경험도 있으며, 이로 인해 스스로의 부족함을 절실히 느꼈습니다.

원티드 포텐업의 커리큘럼과 멘토님들의 도움을 통해 부족한 지식을 보완하고, 실무에 적용할 수 있는 능력을 키워 효율적이고 발전된 개발자로 성장하고 싶습니다. 멘토님들과의 소통을 통해 업계의 실제 사례와 다중 사용자 기반 네트워크 콘텐츠 제작 경험을 배우고, 언리얼 리슨, 데디케이티드 서버의 동작 구조, Property와 RPC 통신을 이용한 네트워크 동기화 처리 방법도 체계적으로 익히고 싶습니다. 이를 통해 개발하는 게임이 더 많은 사용자들에게 즐거움을 줄 수 있도록 기여하며, 더 나은 사용자 경험을 제공하고 싶습니다. 또한, 다른 개발자들과의 협업을 통해 프로젝트를 성공적으로 이끄는 데 필요한 소프트 스킬도 함께 함양하고 싶습니다.

[C++11 - library features] std::begin/end

deulee — Mon, 28 Aug 2023 16:30:43 +0900

`std::begin`과 `std::end`는 C++11에서 도입된 컨테이너의 일반적인 `begin`과 `end` 반복자를 반환해주는 기능이다.

이들의 특징은 특정 클래스의 멤버 함수로써 존재하는 것이 아니라 "raw array"와 같이 `begin`과 `end` 멤버 함수가 없는 배열에도 유용하게 사용된다는 것이다.

#include <iostream>
#include <vector>
#include <algorithm>

template <typename T>
int CountTwos(const T& container)
{
	return std::count_if(std::begin(container), std::end(container), [](int item){
		return item == 2;
	});
}

int main(void)
{
	std::vector<int> vec = {2, 2, 43, 435, 4345345, 3434};
	int arr[8] = {2, 12, 13 ,15 , 1, 66, 3, 9};
	auto a = CountTwos(vec); // 2
	auto b = CountTwos(arr); // 1
	std::cout << a << ' ' << b << std::endl;
	return 0;
}

[C++11] Move Semantics

deulee — Mon, 28 Aug 2023 16:13:44 +0900

"Move Semantics(이동 의미론)"은 C++11로부터 도입된 핵심적인 개념으로, 객체의 "소유권"을 전환하거나 "전달"하는 방식을 나타낸다.

이는 C++에서 더 효율적인 객체 복사와 동적 자원 관리를 가능하게 해준다.

"Move Semantics"를 이용하면 임시 객체나 rvalue로부터 객체의 리소스를 효율적으로 이동시켜 새로운 객체를 생성하거나 기존 객체에 리소스를 할당할 수 있다. 이를 통해 복사 대신 리소스의 소유권을 이전함으로써 성능을 최적화시킬 수 있다.

특히, 동적 메모리 할당과 같이 무거운 작업에서 효율적이다.

그럼 주로 어디에서 사용할까?

객체의 수명이 다할때
객체가 일시적으로 사용될 때
`std::move`로 인해 명시적으로 호출될 때

보통 이 세 가지 상황에서 사용되는데 다음의 예시를 들도록 하겠다.

`std::vector`의 경우 "이동"을 하게 되면 단순히 몇개의 포인터를 복사하고 내부의 상태를 새로운 벡터에 넘기게 될 것이다. 하지만 "복사"를 하게 된다면 벡터의 포함되어 있는 모든 요소를 일일이 복사하게 될 것이다. 어차피 기존의 객체는 곧 파괴될텐데 말이다.

또한, 복사가 불가능한 타입 (`std::unique_ptr`)과 같은 타입도 이동이 가능하게 해준다.

이를 코드로 이용한 내용은 다음 글을 참고하자.

https://deulee.tistory.com/121

[C++11] Rvalue references

"Rvalue reference"는 C++11에서 도입된 기능으로 오로지 Rvalue에만 할당될 수 있는 새로운 레퍼런스이다. 이를 선언하는 방법은 다음과 같다. T&& // where T is non-template type parameter (such as int, or a user-defined

deulee.tistory.com

https://deulee.tistory.com/101

[C++11] Special member functions for move semantics

복사 생성자와 복사 대입 연산자는 복사본이 만들어질 때 호출됐었다. 하지만 C++11의 `move semantics`가 생기면서 `move constructor`와 `move assignment operator`를 만들 수 있게 되었다. #include class B { public: st

deulee.tistory.com

[C++11] Rvalue references

deulee — Mon, 28 Aug 2023 15:54:33 +0900

"Rvalue reference"는 C++11에서 도입된 기능으로 오로지 Rvalue에만 할당될 수 있는 새로운 레퍼런스이다.

이를 선언하는 방법은 다음과 같다.

T&& // where T is non-template type parameter (such as int, or a user-defined type)

그럼 "Rvalue reference"가 어떻게 바인딩되는지 확인해보자.

#include <iostream>

int main(void)
{
	int x = 0; // `x` is an lvalue of type `int`
	int& xl = x; // `x1` is an lvalue of type `int&`
	int&& xr = x; // error -- `x` is an lvalue
	int&& xr2 = 0; // `xr2` is an lvalue of type `int&&` -- binds to the rvalue temporary, `0`

	void f(int& x) {}
	void f(int&& x) {}

	f(x); // calls f(int&)
	f(xl); // calls f(int&)
	f(3); // calls f(int&&)
	f(std::move(x)); // calls f(int&&)

	f(xr2); // calls f(int&)
	f(std::move(xr2)); // calls f(int&&)
	return 0;
}

"Rvalue Reference"는 위와 같은 규칙을 가지게 된다.

그럼 다음과 같은 의문점이 생길 수 있다. 왜 `f(xr2)`는 `f(int&)` 함수를 호출하는 것일까? 분명한 것은 `xr2`의 타입이 `int&&`로 선언되었는데 말이다.

우선 Rvalue와 Lvalue의 차이점을 알 필요가 있다.

Rvalue vs Lvalue

Rvalue와 Lvalue는 이름에서도 나오듯이 차이점이 뚜렷한 "값 카테고리"다.

그럼 어떤 부분에서 차이가 있을까?

Lvalue

lvalue는 "메모리에서 위치를 가지는 변수나 객체"를 나타냄.
변수의 이름이나 객체의 이름은 lvalue이다.
lvalue는 주소를 가지며, 해당 주소를 통해 값을 변경하거나 접근할 수 있다.
ex) 변수 `x`, 배열 요소 `arr[3]`, 클래스 객체 `obj`

Rvalue

rvalue는 "메모리에서 위치를 가지지 않는 일시적인 값"을 나타냄.
임시적인 값을 나타내거나, 표현식의 결과 값이나 상수 등이 rvalue이다.
rvalue는 주소를 가지지 않으며, 일반적으로 임시적으로 생성되는 값이다.
ex: 리터럴 상수 `42`, 표현식 `x + y`, 함수 호출 결과 `getNumber()`

그럼 이제 위의 예제에서 `int&& z = 0`에서 `f(z)`를 호출할 때 `f(int&)`가 호출되는지 설명하도록 하겠다.

앞서 설명했듯이, rvalue는 임시적인 값(메모리에서 위치를 가지지 않는 값)을 의미했다.

하지만 `main` 함수의 scope에서는 "rvalue"의 타입으로 선언된 변수 `z`는 더 이상 임시적인 값이 아니다. 즉, 메모리에서 위치를 가지고 있는 것이다. 이 말은 변수 `z`는 "rvalue"의 타입으로 초기화되었지만 "lvalue"의 속성을 가지게 된다.

그러므로 `f(int&)`가 호출되는 것이다.

[C++11] Forwarding References(Universal References)

deulee — Mon, 28 Aug 2023 15:26:32 +0900

"Forwarding References" 혹은 "Universal References"은 C++11에서 도입된 기능으로, 주로 함수 템플릿의 매개변수로 사용되는 형태를 가리키는 용어다.

함수 템플릿으로 전달된 인자를 "원본의 값 카테고리와 레퍼런스 유형을 유지하면서 다른 함수로 전달하는 메커니즘"을 일컷는다.

C++에는 Lvalue와 Rvalue이라는 값 카테고리가 있는데 주요 특징은 다음과 같다.

Lvalue : 주소를 가질 수 있는 변수나 객체를 의미함. (변수, 포인터)
Rvalue : 주소를 가질 수 없는 일시적인 값. (정수 리터럴)

이때 "Forwarding References"는 이러한 값 카테고리를 유지하면서 인자를 전달하는데 사용된다.

Forwarding Reference의 생성 방법은 다음과 같다.

T&& // Where `T` is a template type parameter
auto&&

"Fowarding References"이 가진 또 다른 특징은, "인자로 전달된 값의 카테고리에 따라 바인딩"이 된다는 것이다.

즉, 다음의 규칙이 성사되는데,

`T& &` == `T&`
`T& &&` == `T&`
`T&& &` == `T&`
`T&& &&` == `T&&`

그럼 이것이 어떻게 활용되는지 예시를 보도록 하자.

#include <iostream>

// Since C++14 or later:
void f(auto&& t) {
	//...
}

template <typename T>
void f(T&& t)
{
	// ...
}

int x = 0;
f(0); // `T` is `int`, deduces as `f(int &&)` => `f(int&&)`
f(x); // `T` is `int&`, deduces as `f(int& &&)` => `f(int&)`

int& y = 0;
f(y); // `T` is `int&`, deduces as `f(int& &&)` => `f(int&)`

int&& z = 0; // `z` is an lvalue with type `int&&`
f(z); // `T` is `int&`, deduces as `f(int& &&)` => `f(int&)`
f(std::move(z)); // `T` is `int`, deduces as `f(int &&)` => `f(int&&)`
return 0;

위의 예시가 어떤 상황에서 어떻게 타입이 추론되는지 상세하게 나타내고 있다.

이렇듯 "Forwarding references"는 주로 함수 템플릿에 사용되며 전달하는 인자의 본래의 값 카테고리를 유지시켜주는 데 중요한 역할을 한다.

[C++11] Variadic templates

deulee — Mon, 28 Aug 2023 14:57:07 +0900

`...` 구문은 가변 인자를 받을 수 있게 된다. 가변 템플릿은 템플릿의 매개 변수로 여러 개의 인자를 받을 수 있도록 하는 기능이다.

이는 함수나 클래스 템플릿을 정의할 때, 인자의 개수가 동적으로 변할 수 있을 때 유용하게 사용된다.

이때, 인자의 갯수는 0개 이상을 받을 수 있다.

이렇게 최소 한개 이상의 가변 인자를 받는 템플릿을 "가변 템플릿"이라고 한다.

#include <iostream>

template <typename... T>
struct Arity {
	constexpr static int value = sizeof...(T);
};

int main(void)
{
	static_assert(Arity<>::value == 0, ""); // OK
	static_assert(Arity<int, char, short>::value == 3, ""); // OK
	return 0;
}

위의 예시를 보면 템플릿의 매개 변수를 아예 받지 않거나 여러 개를 받았을 때의 모습을 확인할 수 있다.

다음 예시는 가변 템플릿을 사용하는 예시를 보도록 하겠다.

template<typename T>
void Print(const T& value)
{
	std::cout << value << " ";
}

template <typename T, typename... Args>
void Print(const T& value, const Args&... args)
{
	std::cout << value << " ";
	Print(args...);
}

int main(void)
{
	Print("hello", 1, 2.7, 'a');
	return 0;
}

다양한 타입의 인자를 받아들이는 것을 확인할 수 있다.

이때 `Print` 함수가 재귀를 돌면서 각각의 인자를 차례대로 호출하는 것을 볼 수 있다.

template <typename First, typename... Args>
auto sum(const First first, const Args... args) -> decltype(first)
{
	const auto values = {first, args...};
	return std::accumulate(values.begin(), values.end(), First{0});
}

int main(void)
{
	std::cout << sum(1, 2, 3) << std::endl;
	return 0;
}

위의 예시는 가변 인자를 이용해 "initializer list"를 만들고 이를 통해 가변 인자의 요소를 가리킬 수 있게 되었다.

[C++11] Initializer lists

deulee — Mon, 28 Aug 2023 13:56:15 +0900

"Initializer lists"는 C++11에서 도입된 객체를 초기화하는 데 사용되는 편리한 방법이다.

이는 "braced list(중괄호)"를 이용하여 만들 수 있는데 예를 들어 `{1, 2, 3}`은 정수의 배열을 만든다. 그리고 이 타입은 `std::initializer_list<int>`가 된다.

이는 함수에 인자로 넘길 때 벡터 대신 사용하기 유용하다.

#include <iostream>

int sum(const std::initializer_list<int>& list)
{
	int total = 0;
	for (auto& it : list)
		total += it;
	return total;
}

int main(void)
{
	auto list = {1, 2, 3}; // `std::initializer_list<int>`
	sum(list); // 6
	sum({1, 2, 3}); // 6;
	sum({}); // 0;
	return 0;
}

[C++11] Static Assertions

deulee — Sat, 26 Aug 2023 18:32:54 +0900

`static_assert`는 C++11부터 제공되는 기능으로 컴파일 시간에 조건을 검사하여 컴파일 타임 에러를 발생시키는 역할을 수행하는 키워드이다.

이를 통해 컴파일 시간에 논리적인 조건을 확인하거나 특정한 제약을 검사하여 코드의 안전성을 높일 수 있다.

`static_assert`의 기본 구조는 다음과 같다.

static_assert(condition, message);

`condition`: 검사하고 싶은 조건을 나타내는 표현식. 만약 이 조건이 `false`로 판단되면 컴파일 에러 발생
`message`: 컴파일 에러 메시지를 지정

예시:

#include <iostream>
#include <type_traits>

template <typename T>
void print_Int() {
	static_assert(std::is_integral<T>::value, "T must be integral type");
	std::cout << "Size of " << typeid(T).name() << ": " << sizeof(T) << " bytes" << std::endl;
}

int main(void)
{
	print_Int<int>();
	// print_Int<double>(); // error
	// print_size<std::string>(); // error: T must be an integral type
	return 0;
}

위 코드에서 `print_Int` 함수는 템플릿으로 정의되어 있다.

`static_assert`를 사용하여 템플릿의 매개변수 `T`가 정수형 타입일 때만 컴파일을 허용하도록 제한하고 있다.

이렇게 함으로써 아래의 `double`와 `std::string`에서 에러를 발생시킨다.

`static_assert`는 코드의 안전성을 높이는데 도움을 주고, 특히 템플릿 메타 프로그래밍이나 일반 코드에서 조건을 검사하여 예기치 않은 문제를 방지하는데 사용된다.

[C++11] auto

deulee — Sat, 26 Aug 2023 18:12:09 +0900

`auto` 키워드는 C++11부터 도입된 기능으로, 변수의 타입을 "컴파일러"가 초기화식을 기반으로 자동으로 추론하도록 하는 기능을 제공한다.

예시를 먼저 보도록 하자.

#include <iostream>

int main(void)
{
	auto a = 3.14; // double
	auto b = 1; // int
	auto& c = b; // int&
	auto d = {0}; // std::initializer_list<int>
	auto&& e = 1; // int&&
	auto&& f = b; // int&
	auto g = new auto(123); // int*
	const auto h = 1; // const int
	auto i = 1, j = 2, k = 3; // int, int, int
	auto l = 1, m = true, n = 1.61; // error -- `l` deduced to be int, `m` is bool
	auto o; // error -- `o` requires initializer
}

우선 위를 보면 궁금한 점이 몇몇 있지만 이는 나중에 다루도록 하겠다.

쨋든, 예시를 보면 초기화 타입에 맞게 알맞게 타입이 추론되는 것을 볼 수 있다.

그리고 이는 가독성을 굉장히 높여주는데 다음의 코드도 보도록 하자.

std::vector<int> v = ...;
std::vector<int>::const_iterator cit = v.cbegin();
// vs
auto cit = v.cbegin();

위의 예제와 같이 코드의 길이를 대폭 줄일 수 있다.

"함수"에서도 `auto` 키워드를 사용하여 리턴 타입을 추론할 수 있다. 하지만 물론 C++11에서는 리턴 타입을 명시적으로 지정해야 하기 때문에 `decltype` 키워드를 사용하여 이를 해결할 수 있다.

template <typename X, typename Y>
auto add(X x, Y y) -> decltype(x + y)
{
	return x + y;
}

add(1, 2); // == 3
add(1, 2.0); // == 3.0
add(1.5, 1.5); // == 3.0

위의 예제에서는 이전에 배운 "trailing return type"과 `decltype`을 이용하여 예시를 작성해보았다.

`auto`의 타입은 `decltype`에 의해 추론된 타입으로 결정되게 된다. 즉, `(x + y)` 표현식에 의해 추론된다는 것이다.

auto의 작동 원리

`auto`의 타입 추론은 대체로 템플릿 타입 추론과 같지만, `auto` 타입 추론은 `{중괄호 초기화}`가 `std::initializer_list`를 나타낸다고 가정하는 반면 템플릿 타입 추론은 그렇지 않다는 차이가 존재한다.

`auto` 키워드는 총 3개의 경우를 통해서 타입을 추론하는데 다음과 같다.

경우 1: 타입 지정자가 포인터나 참조 타입이지만 보편 참조(universal reference)는 아닌 경우.
경우 2: 타입 지정자가 보편 참조(universal reference)인 경우.
경우 3: 타입 지정자가 포인터도 아니고 참조도 아닌 경우.

#include <iostream>

// 경우 1 : 타입 지정자가 포인터나 참조 타입이지만 보편 참조(universal reference)가 아닌경우
// 경우 2 : 타입 지정자가 보편 참조(universal reference)인 경우
// 경우 3 : 타입 지정자가 포인터도 아니고 참조도 아닌 경우.

int main(void)
{
	// `int`
	auto x = 13; // 경우 3 -- x는 포인터도 아니고 참조도 아님

	// `const int`
	const auto cx = x; // 경우 3 -- cx는 포인터도 아니고 참조도 아님	

	// `const int&`
	const auto& rx = x; // 경우 1 -- rx는 보편 참조(universal reference)가 아닌 참조

	// `int&`
	auto&& uref1 = x; // x는 `int`이자 lvalue이므로 uref1의 타입은 `int&`

	// `const int&`
	auto&& uref2 = cx; // cx는 `const int`이자 lvalue이므로 uref2의 타입은 `const int&`

	// `int&&`
	auto&& uref3 = 27; // 27은 `int`이자 rvalue이므로 uref3의 타입은 `int&&`
}

이로써 맨 처음에 생긴 의문이 어느정도는 해결되었다.

이런 타입 추론에 관련해서는 나중에 "Modern Effective C++"이라는 책을 통해 더 자세하게 작성하도록 하겠다.

우선은 `auto`라는 키워드가 있고 어떻게 사용하는지 아는 것에 만족하자.

[C++11] Lamda Expressions

deulee — Sat, 26 Aug 2023 17:42:45 +0900

`lamda`는 C+11부터 도입된 기능으로, 이름 없는 함수 객체로 지역내에 있는 변수들을 캡처하는 기능이 있다.

우선 `lamda`의 구조는 다음과 같다.

[capture](parameters) -> return_type {
	// 함수 몸체
} (call lamda); // 생략 가능

각각의 요소는 다음과 같다.

`capture`는 외부 변수를 람다 내부에서 사용할 때 그 값을 어떻게 캡처할 것인지를 지정함.
`parameters`는 람다 함수의 매개변수를 정의함.
`return_type`은 람다 함수의 반환 타입을 지정함. (생략 가능)
`함수 몸체`는 실제 함수의 내용을 작성하는 부분
`호출 인자`는 함수 호출 시 인자를 의미함. (생략 가능)

캡처를 할 때 다양한 특징이 있는데 다음과 같다.

`[]` - 아무것도 캡처하지 않음.
`[=]` - 지역내의 모든 객체 (지역 변수, 매개 변수)의 값을 복사함.
`[&]` - 지역내의 모든 객체 (지역 변수, 매개 변수)의 값을 참조함
`[this]` - `this`를 참조함
`[a, &b]` - `a`의 값을 복사하고 `b`를 참조함.

예시는 다음과 같다.

#include <iostream>

int main(void)
{
	int x = 1;

	auto getX = [=] { return x; };
	std::cout << getX() << std::endl; // == 1

	auto addX = [=](int y) { return x + y; };
	std::cout << addX(3) << std::endl; // == 4;

	auto getXRef = [&]() -> int& { return x; };
	int& y = getXRef();
	y = 6;
	std::cout << x << std::endl; // 6;
	return 0;
}

람다는 또한 함수의 인자로서 넣어질 수 있다. 마치 함수 포인터처럼 말이다.

std::vector<int> varr{0, 4, 6, 1, 3, 4};
std::sort(varr.begin(), varr.end(), [](int x, int y){return x < y;});
for (auto& it : varr)
	std::cout << it << ' '; // 0 1 3 4 4 6
std::cout << std::endl;

주의할 점

우선 디폴트로, "value-captures" 즉, 값으로 캡처 된 것은 남다 내부에서 변경하는 것이 금지 되어있다.

그 이유는, 컴파일러 생성 메서드는 `const`로 표시되기 때문이다.

하지만 "parameter-list" 이후에 `mutable` 키워드를 지정하게 될 시 "value-captured" 값을 바꿀 수 있게 된다.

auto f1 = [&x] { x = 2; }; // OK: x is a reference and modifies the original
auto f2 = [x] { x = 2; }; // error -- the lamda can only perform const-operations on the captured value
auto f3 = [x]() mutable { x = 6; }; // OK: the lamda can perform any operations on the captured value