3D Client Programmer

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