3D Client Programmer

우리가 STL에서 어떤 요소를 삭제하려면 굉장히 귀찮은 작업을 했었다.

기존의 STL Vector에서의 요소 삭제 코드

int main()
{
    std::vector<int> vec = { -1, 1, -2, 2, -3, 3};
    
    for (auto it = vec.begin(); it != vec.end();)
    {
        auto value = *it;
        if (value < 0)
        {
            it = vec.erase(it);
        }
        else
        {
            ++it;
        }
    }
    
    return 0;
}

위와 같이 삭제 코드가 굉장히 길고 실수할 여지가 다분하다.

그래서 뒤에 나온 remove_if를 이용해서 삭제를 했었다.

int main()
{
    std::vector<int> vec = { -1, 1, -2, 2, -3, 3 };
    auto newEnd = std::remove_if(vec.begin(), vec.end(), [](int n) { return n < 0; });
    vec.erase(newEnd, vec.end());
    
    return 0;
}

드디어 erase_if가 나와서 좀 더 편하게 사용할 수 있다.

int main()
{
    std::vector<int> vec = { -1, 1, -2, 2, -3, 3 };
    
    std::erase(vec, 2); // 2만 삭제.
    std::erase_if(vec, [](int n) { return n < 0; }); // 0보다 작은 것들 삭제.

    return 0;
}

C++11 Typed Lambda

auto sumTyped = [](int a, int b) { return a + b; }

C++14 Generic Lambda

auto sumGeneric = [](auto a, auto b) { return a + b; }

위의 Lambda도 그 동안 편하게 사용하고 있었는데 이제는 템플릿을 이용해서 사용할 수 있게 되었다.

auto sumTemplate = []<template T>(T a, T b) { return a + b; }

우리가 알고 있는 template를 선언할 때는 아래와 같다

template<typename T>

여기에서 typename 대신에 NonType으로 다음과 같이 사용이 가능했다.

int, enum, pointer, reference, nullptr_t 등은 기존에도 사용이 가능했다.

template<int T>

이번 C++20에서는 몇가지를 더 사용할 수 있게 되었다.

- Floating-point
- Literal Type (types of constexpr variables)
- String Literal

Floating-point를 사용하는 예제

template<double d>
auto GetDouble()
{
   return d;
}

int main()
{
    auto d1 = GetDouble<5.5>();

    return 0;
}

Literal Type (types of constexpr variables)을 사용하는 예제

struct ClassType
{
    constexpr ClassType(int) {}
}

template<ClassType t>
auto GetClassType()
{
    return t;
}

int main()
{
    auto t1 = GetClassType<1>();

    return 0;
}

String Literal

template<int N>
class StringLiteral
{
public:
    constexpr StringLiteral(char const (&str)[N])
    {
        std::copy(str, str+N, _data);
    }
    
    char _data[N];
}

template<StringLiteral str>
class ClassTemplate {};

template<StringLiteral str>
void FunctionTemplate()
{
    cout << str data << endl;
}

int main()
{
    ClassTemplate<"Hello World"> cls1;
    FunctionTemplate<"Hello">();

    return 0;
}

explicit 키워드는 알고 있다시피 명시적으로 생성자를 호출하겠다는 의미이다.

조건부 explicit 생성자 키워드는 template를 사용할 때 편하게 이용할 수 있을 것 같다.

strcut A
{
    template<typename T>
    explicit(!std::is_same<T, bool>::value) A(T t)
    {
        cout << typeid(t).name() << endl;
    }
}

void TestA(A a)
{
}

int main()
{
    A a(true);
    TestA(a);     // 기본적으로 성공
    TestA(true);  // 조건이 맞기 때문에 성공
    TestA(10);    // 조건이 틀리므로 실패
    
    return 0;
}

constinit은 CompileTime에 상수로 사용하지만, 일반적인 const와는 다르게 변수처럼 사용이 가능하다

특징

1. CompileTime에 상수로 지정된다.
2. constness는 없다. (즉, 값을 변경할 수 있다)
3. global, static, thread_local 변수에서 사용해야된다. (즉, 일반 변수에는 사용할 수 없다)

위의 특징 중에 "값을 변경할 수 있다." 이 부분이 굉장히 특이하다.

아래의 코드와 같이 globalA의 값이 상수임에도 변경해서 사용할 수 있다.

constinit int globalA = 10;
constexpr int globalB = 20;

int main()
{
    globalA = 11; // 성공
    globalB = 21; // 이건 에러
    return 0;
}

하지만, 이걸 사용할 일이 있을지는 의문이든다. const를 사용한다는건 기본적으로 상수로 보장시키기 위한 것 아닌가...?

consteval은 Compile Time은 오래 걸리더라도 미리 계산을 다 해놓겠다고 지정하는 것이라고 생각 하면된다.

우리 모두가 알고 있듯이 아래 함수는 RunTime에 계산이 된다 

int Square(int n)
{
    return n * n;
}

하지만 다음과 같이 consteval 키워드를 붙여주면 컴파일 타임에 계산이되어서 상수로 들어가게된다.

consteval int SquareConstEval(int n)
{
    return n * n;
}

무슨 말인가하면 프로그램을 디스어셈블리로 확인해보면 좀 더 쉽게 확인할 수 있다.

위에 사진을 보면 Square(10)의 경우 어셈블리로 move, call, move가 RunTime에 직접 계산이 된 것을 확인 할 수 있지만, 아래 SquareConstEval(10)의 경우에는 mov 어셈블리 밖에 없다 왜냐하면 CompileTime에 이미 계산이 된 채로

"int b = 100;" 으로 변경이 된 상태이기 때문이다.

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

다음과 같이 변수 선언과 동시에 중괄호"{}" 사이에 .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;
}