3D Client Programmer

이건 다른 언어에서 이미 있었던 기능인데 원하는 변수만 지정해서 초기화하는 기능이다.

다음과 같이 변수 선언과 동시에 중괄호"{}" 사이에 .b 와 같이 "."을 붙여서 원하는 변수만 초기화가 가능하다.

struct MyStruct
{
    int a;
    int b;
    int c;
};

int main()
{
    MyStruct m{.b = 3};
    
    return 0;
}

C++에서 비교 연산자를 만들 때 <, <=, ==, !=, >=, > 등을 모두 만들어야하는 상황이 있었다.

이것을 한번에 만들어주는 거라고 보면된다.

쉽게 보면 아래와 같이 기존에 6개의 Operator를 만들어야했지만, 1개만 만들면 자동으로 모두 사용할 수 있게 된다.

struct MyInt
{
    MyInt(int value) : _value(value) { }

    // 기존 문법
    bool operator<(const MyInt& rhs) const { return _value < rhs._value; }
    bool operator<=(const MyInt& rhs) const { return _value <= rhs._value; }
    bool operator>(const MyInt& rhs) const { return _value > rhs._value; }
    bool operator>=(const MyInt& rhs) const { return _value >= rhs._value; }
    bool operator==(const MyInt& rhs) const { return _value == rhs._value; }
    bool operator!=(const MyInt& rhs) const { return _value != rhs._value; }

    // C++ 20 삼항 비교 연산자
    auto operator<=>(const MyInt& rhs) const = default;

    int _value;
};

아래와 같이 문자열 비교와 동일한 결과가 나오게 된다.

int main()
{
    int a1 = 100;
    int b1 = 200;

    auto ret = (a1 <=> b1);

    if (ret < 0)
        cout << "a < b" << endl;
    else if (ret == 0)
        cout << "a == b" << endl;
    else if (ret > 0)
        cout << "a > b" << endl;
        
    return 0;
}

이번 C++ 20에서 가장 기대했던 기능이라서 책도보고 인터넷 검색도 계속하면서 공부를 해본 결과 현재로썬 쉽게 사용하기는 힘들 것 같다...

회사 프로젝트에 적용하기에는 위험 부담이 있다... (디버깅이 너무 힘들 것 같다...)

아마도 코루틴을 이용하는 디자인 패턴이 좀 나오면서 정리가 되면 그때 사용하게 되지 않을까...? 하는 생각이 들 정도이다.

유니티를 하면서 코루틴이라는 개념을 처음 접했었는데 개념 자체는 크게 다르진 않은 것 같다.

코루틴의 개념은 이 포스팅에서 잘 설명을 해주고 있다.

(https://m.post.naver.com/viewer/postView.naver?volumeNo=33676443&memberNo=559061)

하지만 사용하기 위해서 준비를 많이 해야되는 부분은 불편해보인다.

다른 언어와 달리 C++은 기본적으로 Framework이 존재하지 않는다.

항상 사용자가 만들어서 사용을하든, 다른 라이브러리를 사용하든 어쨋든 간에 별도의 Framework을 생성해야만 한다.

그래서 이러한 준비(약속)가 필요하다.

가장 기본적으로 필요한 것은 promise_type이다.

struct promise_type
{
    // 코루틴의 객체를 반환한다.
    CoroutineObject get_return_object() { return {}; }
    
    // 코루틴이 실행 전에 멈춰있어야하는지 확인
    std::suspend_never initial_suspend() const noexcept { return {}; }
    
    // 코루틴이 종료 전에 멈춰있어야하는지 확인
    std::suspend_never final_suspend() const noexcept { return {}; }
    
    // co_return에 의해 호출 (코루틴이 무한 루프로 종료되지 않는다면 불필요)
    void return_void() { }
    
    // co_return val에 의해 호출됨
    void return_value(T value) { *_ptr = value; }
    
    // co_yield에 의해 호출
    std::suspend_always yield_value(const T value) { _value = value; return {}; }
    
    // 예외 발생
    void unhandled_exception() { }
};

C++에서의 코루틴 promise_type이라는 객체를 만들어서 커스터마이징을 해야되고, 이것을 이용해서 우리가 아는 코루틴의 개념에 맞게 직접 구현해야한다.

구현 내용이 너무 길기 때문에 그냥 다른 포스팅으로 대체한다.

https://openmynotepad.tistory.com/65

https://openmynotepad.tistory.com/66

https://openmynotepad.tistory.com/67

Ranges는 STL에서 제공되던 iterator의 확장 버전처럼 보인다.

Range : STL 컨테이너를 순회할 수 있는 그룹
View : Range에 대해서 적용할 수 있는 연산

C#의 LINQ 문법과 비슷하다.

키워드 

// std::views::all		
// std::ranges::filter_view / std::views::filter (조건 만족하는거 추출)
// std::ranges::transform_view / std::views::transform (각 요소를 변환)
// std::ranges::take_view / std::views::take (n개 요소를 추출)
// std::ranges::take_while_view / std::views::take_while (조건 만족할 때까지 요소 추출)
// std::ranges::drop_view / std::views::drop (n개 요소를 스킵)
// std::ranges::drop_while_view / std::views::drop_while (조건 만족할 때까지 요소 스킵)
// std::ranges::join_view / std::views::join (view 를 병합)
// std::ranges::split_view / std::views::split (split)
// std::ranges::reverse_view / std::views::reverse (역순서로 순회)
// std::ranges::elements_view / std::views::elements (튜플의 n번째 요소를 대상으로 view 생성)
// std::ranges::keys_view / std::views::keys (pair-like value의 첫번째 요소를 대상으로 view 생성)
// std::ranges::values_view / std::views::values (pair-like value의 두번째 요소를 대상으로 view 생성)

벡터의 값들 중에 짝수를 추출해서 2를 곱해준다는 것을 코드로 구현한다면

예전 코드

vector<int> v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

vector<int> v2;
// 짝수를 추출해서
for (int n : v1)
	if (n % 2 == 0)
		v2.push_back(n);
        
// 2를 곱해준다
for (int& n : v2)
	n = n * 2;

view를 이용한 코드

vector<int> v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

auto results = v1 | std::views::filter([](int n) { return n % 2 == 0; })
                  | std::views::transform([](int n) { return n * 2; });

정렬 방법

vector<int> v1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

std::sort(v1.begin(), v1.end()); // 예전 방식
std::ranges::sort(v1);			 // range를 이용한 방식

ref - https://openmynotepad.tistory.com/87

https://openmynotepad.tistory.com/88

C++은 다른 라이브러리를 사용하려면 무조건 헤더를 포함(#include <>) 해서 사용해야하지만, 뒤에 나온 언어에서는 그냥 import만해도 해당 기능을 사용할 수 있다.

그래서 ixx를 만든 것 같다.

Module의 장점

1. 모듈은 1번만 import 된다
2. import의 순서에 상관없다
3. 모듈의 이름을 지정할 수 있다
4. 인터페이스와 구현부를 분리 할 필요가 없다

ixx 파일 사용 방법

module; // global module fragment

// 각종 외부 헤더 추가
#include <vector>

// module 시작
export module math;

// import module ...

// submodule
export import math.time;

// 3) namespace를 지정
export namespace math
{
	template <typename T>
	T Add(T a, T b)
	{
		return a + b;
	}
}

일반 cpp에서 사용 방법

#include <iostream>
using namespace std;

import math;

int main()
{
	auto addValue = math::Add(1, 2);
}

파티션이라는 기능도 제공한다. 이 기능은 ixx하나에 모든 내용을 넣기에는 부담스럽기 때문에 여러개의 파티션(:)으로 나눌 수 있다.

MathPartition.ixx

export module MathPartition;

// Partition
export import :MathPartition_1;
export import :MathPartition_2;

MathPartition_1.ixx

export module MathPartition:MathPartition_1;

export void MyFunc()
{

}

MathPartition_2.ixx

export module MathPartition:MathPartition_2;

export void MyFunc2()
{

}

일반 cpp

#include <iostream>
using namespace std;

import math;

import MathPartition;


int main()
{
	auto addValue = math::Add(1, 2);

	MyFunc();
	MyFunc2();
}

ref - https://openmynotepad.tistory.com/78

https://openmynotepad.tistory.com/79

우리가 템플릿을 사용할 때 어떤 타입에 대한 제한을 두고 싶을 때 아래와 같이 static_assert를 이용했었다.

template<class T>
engine_ptr<T> NewComponent(const std::wstring& newName, const engine_ptr<const T> newOther)
{
    LOG_ENTRY;

    static_assert(std::is_base_of<Component, T>::value, "NewComponent must base of Component");
    engine_ptr<T> component = Entity::NewComponent<T>(newName, this, newOther);
    components_.emplace_back(component);

    return component;
}

static_assert()를 이용할 때에는 함수 구현부에 해당 내용이 들어가야한다.

C++ 20에서는 concepts(https://en.cppreference.com/w/cpp/language/constraints)를 이용할 수 있다.

아래와 같이 requires 키워드를 이용하여 해당 타입일 때에만 template가 될 수 있게 할 수 있다.

// 1) Requires Clause(절)
template<typename T>
requires std::integral<T>
void TestConcept1(T number)
{
	cout << number << endl;
}

// 2) Trailing Requires Clause (뒤에 붙는~)
template<typename T>
void TestConcept2(T number) requires std::integral<T>
{
	cout << number << endl;
}

// 3) Constrained Template Parameter (강요된)
template<std::integral T>
void TestConcept3(T number)
{
	cout << number << endl;
}

// 4) Abbreviated Function Template
void TestConcept4(std::integral auto number)
{
	cout << number << endl;
}

이것을 응용하면 아래와 같이 커스터마이징을 할 수 있다.

class GameObject
{

};

class Knight : public GameObject
{

};

template<typename T>
requires std::derived_from<T, GameObject>
void TestObj(T* obj)
{

}

template<typename T>
concept MyConcept = !std::is_integral_v<T> && std::derived_from<T, GameObject>;

template<typename T>
concept Addable = requires (T a, T b)
{
	a + b;
}; // a + b가 가능해야 함

template<typename T>
concept Equality = requires(T a, T b)
{
	{ a == b } -> std::convertible_to<bool>;
	{ a != b } -> std::convertible_to<bool>;
};

template<typename T>
concept Integral = std::is_integral_v<T>;

template<typename T>
concept SignedInt = Integral<T> && std::is_signed_v<T>;

ref - https://openmynotepad.tistory.com/69

https://openmynotepad.tistory.com/66

https://openmynotepad.tistory.com/71

https://openmynotepad.tistory.com/72

언리얼5 공식 문서 : https://docs.unrealengine.com/5.0/ko/

용어 정리 : https://chogyujin-study.tistory.com/13

Unity와 비교하여 용어 정리 : (https://velog.io/@cedongne/UE4-%EC%96%B8%EB%A6%AC%EC%96%BC-%EC%97%94%EC%A7%84-%EC%9A%A9%EC%96%B4-%EC%95%8C%EC%95%84%EB%B3%B4%EA%B8%B0-vs-Unity)

요약

 - 컨텍스트 : 고루틴에 작업을 요청할 때 작업 취소나 작업 시간 등을 설정할 수 있는 작업 명세서 역할

새로운 고루틴으로 작업을 시작할 때 일정 시간 동안만 작업을 지시하거나 외부에서 작업을 취소할 때 사용한다

또한 작업 설정에 관한 데이터를 전달할 수도 있다

작업 취소가 가능한 컨텍스트

// 작업이 취소될 때까지 1초마다 메시지를 출력하는 고루틴
package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func main() {
	wg.Add(1)
	ctx, cancel := context.WithCancel(context.Background()) // 1. 컨텍스트 생성
	go PrintEverySecond(ctx)
	time.Sleep(5 * time.Second)
	cancel()

	wg.Wait()
}

func PrintEverySecond(ctx context.Context) {
	tick := time.Tick(time.Second)

	for {
		select {
		case <-ctx.Done():
			wg.Done()
			return
		case <-tick:
			fmt.Println("Tick")
		}
	}
}

// Tick 5번 출력

작업 시간을 설정한 컨텍스트

// 일정 시간동안만 작업을 지시할 수 있는 컨텍스트
package main

import (
	"context"
	"fmt"
	"sync"
	"time"
)

var wg sync.WaitGroup

func main() {
	wg.Add(1)
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second) // 1. 컨텍스트 생성
	go PrintEverySecond(ctx)
	time.Sleep(5 * time.Second)
	cancel()

	wg.Wait()
}

func PrintEverySecond(ctx context.Context) {
	tick := time.Tick(time.Second)

	for {
		select {
		case <-ctx.Done():
			wg.Done()
			return
		case <-tick:
			fmt.Println("Tick")
		}
	}
}

// Tick 3번 출력

특정 값을 설정한 컨텍스트

// 컨텍스트에 특정 키로 값을 읽어올 수 있도록 설정할 수 있다
package main

import (
	"context"
	"fmt"
	"sync"
)

var wg sync.WaitGroup

func main() {
	wg.Add(1)
	ctx := context.WithValue(context.Background(), "number", 9) // 1. 컨텍스트 생성 (값 추가)
	ctx = context.WithValue(ctx, "float", 5.0)
	ctx = context.WithValue(ctx, "keyword", "Lilly")
	go print(ctx)

	wg.Wait()
}

func print(ctx context.Context) {
	if v := ctx.Value("number"); v != nil { // 2. 컨텍스트에서 값 읽기
		n := v.(int)
		fmt.Println("number:", n*n)
	}

	if v := ctx.Value("float"); v != nil { // 3. 컨텍스트에서 값 읽기
		n := v.(float64)
		fmt.Println("float:", n*n)
	}

	if v := ctx.Value("keyword"); v != nil { // 4. 컨텍스트에서 값 읽기
		n := v.(string)
		fmt.Println("keyword:", n)
	}

	wg.Done()
}

number: 81
float: 25
keyword: Lilly

책 참조 : Tucker의 Go언어 프로그래밍