Hello World

[C++11] 이동 생성자(Move Constructors)와 이동 할당 연산자(Move Assignment Operators)

Eskeptor — Sun, 1 Dec 2024 18:33:18 +0900

C++11에 들어서서 rvalue (Right-value)에 대한 기능(?)들이 생기기 시작 했었습니다.

그 중에서 이동 생성자(Move Constructors)와 이동 할당 연산자(Move Assignment Operators)에 대한 이야기 입니다.

기본 레퍼런스 내용

How to: Define move constructors and move assignment operators (C++)

Learn more about: Move Constructors and Move Assignment Operators (C++)

learn.microsoft.com

지금부터 나올 이야기는 위의 MS Learn(구 MSDN)에 나온 이야기와 기타 공부를 했었던 내용의 짬뽕입니다.

rvalue (Right-value)와 lvalue (Left-value)

이 이야기를 다루기 위해서는 rvalue와 lvalue에 대해서 먼저 이야기해야 합니다.

통상적으로 Right-value를 뜻하는 rvalue는 리터럴(Literal) 혹은 임시 객체(Temporary Object)라고 불리우는 그것 입니다.

즉, 쉽게 말해서 주소값, 레퍼런스화 할 수 없는 값입니다.

int nNum = 33;   // 33은 rvalue

이렇게 흔히 Right-side에 오는 값이어서 Right-value라고 불리웁니다.

하지만 위에서 말했듯이 오른쪽에 오는 리터럴(Literal) 혹은 임시 객체(Temporary Object)에만 해당하는 값만 rvalue라고 합니다.

그럼 lvalue는 rvalue의 반대 개념이겠죠?

즉, 주소값을 취할 수 있는, 레퍼런스화 할 수 있는 값을 말합니다.

int nNum = 33;     // nNum은 lvalue
int& nlNum = nNum; // nNum은 lvalue임으로 레퍼런스를 취할 수 있음

그렇기 때문에 이렇게 위의 예제에서 nlNum이라는 레퍼런스 변수에 대입할 수 있습니다.

이렇게 Left-side에 오는 값이어서 Left-value라고 불립니다.

하지만 lvalue가 Right-side에 간다고 해서 rvalue가 되지는 못합니다.

(그 이유는 rvalue에서 설명 했습니다.)

이동 생성자 (Move Constructors)

이동 생성자의 경우 rvalue 참조 선언자(&&)를 사용합니다.

class MyClass
{
public:
    /**
     * @brief   Copy constructor
     * @param   cls         복사 대상인 데이터
     */
    MyClass(const MyClass& cls)
    {
        m_nLength = cls.m_nLength;
        m_pszName = new char[m_nLength + 1];
        ::strcpy_s(m_pszName, m_nLength + 1, cls.m_pszName);

        std::cout << "복사 생성자: " << m_pszName << std::endl;
    }
    
    /**
     * @brief   Move constructor (noexcept를 선언해주어야 함)
     * @param   cls         이동 대상인 데이터 (rvalue 참조 선언자)
     */    
    MyClass(MyClass&& cls) noexcept
    {
        m_pszName = cls.m_pszName;
        m_nLength = cls.m_nLength;
        
        cls.m_nLength = 0;
        cls.m_pszName = nullptr;    // 제거하지 못하도록 nullptr로 바꾸어버림

        std::cout << "이동 생성자: " << m_pszName << std::endl;
    }
    
    /**
     * @brief   Deconstructor
     */
    ~MyClass() noexcept
    {
        delete[] m_pszName;
    }
    
    /* 생략 */
private:
    int m_nLength;      // 문자열 데이터의 길이 (\0 제외)
    char* m_pszName;    // 문자열 데이터
};

이동 생성자의 경우 rvalue 참조 선언자(&&)로 이동할 인자를 받고 내부에서는 이동하도록 코드를 짜줍니다.

위의 경우에는 이동할 데이터인 cls가 현재 생성되는 데이터로 문자열 데이터(m_pszName)을 넘겨주고 cls 내부의 문자열 데이터(m_pszName)을 nullptr로 바꾸어 줌으로써 cls가 소멸할 때 이동한 데이터를 제거하지 못하도록 합니다.

또한 해당 이동 생성자의 경우 noexcept 이어야만 합니다.

이동 할당 연산자(Move Assignment Operators)

이동 할당 연산자의 경우에도 이동 생성자와 유사합니다.

/**
 * @brief   Move assignment operator
 * @param   cls         이동 대상인 데이터
 * @return  
 */
MyClass& operator=(MyClass&& cls) noexcept
{
    if (this != &cls)
    {
        delete[] m_pszName;

        m_pszName = cls.m_pszName;
        m_nLength = cls.m_nLength;

        cls.m_nLength = 0;
        cls.m_pszName = nullptr;  // 제거하지 못하도록 nullptr로 바꾸어버림
    }
    return *this;
}

이동 할당 연산자에도 rvalue 참조 선언자(&&)로 선언되며 이 또한 noexcept 이어야만 합니다.

여기까지의 예제

여기까지 만든 MyClass는 아래와 같습니다.

#include <iostream>
#include <string>

class MyClass
{
public:
    /**
     * @brief   Copy constructor (문자열 복사)
     * @param   pszName     복사할 문자열
     */
    MyClass(const char* pszName)
    {
        m_nLength = static_cast<int>(::strlen(pszName));
        m_pszName = new char[m_nLength + 1];
        ::strcpy_s(m_pszName, m_nLength + 1, pszName);

        std::cout << "문자열 복사 생성자: " << m_pszName << std::endl;
    }

    /**
     * @brief   Move constructor (noexcept를 선언해주어야 함)
     * @param   cls         이동 대상인 데이터 (rvalue 참조 선언자)
     */
    MyClass(MyClass&& cls) noexcept
    {
        m_pszName = cls.m_pszName;
        m_nLength = cls.m_nLength;
        cls.m_nLength = 0;
        cls.m_pszName = nullptr;

        std::cout << "이동 생성자: " << m_pszName << std::endl;
    }
    /**
     * @brief   Copy constructor
     * @param   cls         복사 대상인 데이터
     */
    MyClass(const MyClass& cls)
    {
        m_nLength = cls.m_nLength;
        m_pszName = new char[m_nLength + 1];
        ::strcpy_s(m_pszName, m_nLength + 1, cls.m_pszName);

        std::cout << "복사 생성자: " << m_pszName << std::endl;
    }

    /**
     * @brief   Deconstructor
     */
    ~MyClass()
    {
        delete[] m_pszName;
        m_pszName = nullptr;
    }

    /**
     * @brief   Move assignment operator
     * @param   cls         이동 대상인 데이터
     * @return  
     */
    MyClass& operator=(MyClass&& cls) noexcept
    {
        if (this != &cls)
        {
            delete[] m_pszName;

            m_pszName = cls.m_pszName;
            m_nLength = cls.m_nLength;

            cls.m_nLength = 0;
            cls.m_pszName = nullptr;
        }
        return *this;
    }

private:
    int m_nLength;      // 문자열 길이
    char* m_pszName;    // 문자열 데이터 (new 하는 데이터로 소멸자에서 제거 예정)
};

int main(void)
{
    MyClass cls1("Hello");              // 문자열 복사 생성자
    MyClass clsCopy = cls1;             // 복사 생성자
    MyClass clsMove = std::move(cls1);  // 이동 생성자

    return 0;
}

자동으로 생성되는 이동 생성자 및 이동 할당 연산자

그럼 항상 이동 생성자와 이동 할당 연산자를 구현해야 할까요?

If a class doesn't define a move constructor, the compiler generates an implicit one if there's no user-declared copy constructor, copy assignment operator, move assignment operator, or destructor. If no explicit or implicit move constructor is defined, operations that would otherwise use a move constructor use the copy constructor instead. If a class declares a move constructor or move assignment operator, the implicitly declared copy constructor is defined as deleted.
출처: https://learn.microsoft.com/en-us/cpp/cpp/constructors-cpp?view=msvc-170#move_constructors

위의 내용을 보면 클래스가 이동 생성자를 정의하지 않았으며 사용자가 복사 생성자, 복사 할당 연산자, 이동 할당 연산자 또는 소멸자를 선언하지 않은 경우 경우 암시적 생성자를 생성한다고 되어있습니다.

MyClass(const MyClass& other);             // 복사 생성자
MyClass& operator=(const MyClass& other);  // 복사 할당 연산자
MyClass(MyClass&& other);                  // 이동 생성자
MyClass& operator=(MyClass&& other);       // 이동 할당 연산자
~MyClass();                                // 소멸자

즉, 위와 같이 선언하지 않았다면 자동으로 생성을 해줍니다.

추가적으로 참조형 변수가 있는 경우에 자동으로 생성해주지 않습니다.

A defaulted copy/move assignment operator for class X is defined as deleted if X has:
- a variant member with a non-trivial corresponding assignment operator and X is a union-like class, or
- a non-static data member of const non-class type (or array thereof), or
- a non-static data member of reference type, or
- a non-static data member of class type M (or array thereof) that cannot be copied/moved because overload resolution (13.3), as applied to M’s corresponding assignment operator, results in an ambiguity or a function that is deleted or inaccessible from the defaulted assignment operator, or
- a direct or virtual base class B that cannot be copied/moved because overload resolution (13.3), as applied to B’s corresponding assignment operator, results in an ambiguity or a function that is deleted or inaccessible from the defaulted assignment operator, or
- for the move assignment operator, a non-static data member or direct base class with a type that does not have a move assignment operator and is not trivially copyable, or any direct or indirect virtual base class.

출처: C++ International Standard N3242(C++11) 12.8 Copying and moving class objects, 24번
https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2011/n3242.pdf

이동과 같이 사용하는 함수) std::move 함수

위에서 봤던 여기까지의 예제 에서 main 함수에서 std::move라는 함수를 봤을 겁니다.

std::move 함수를 썼을 때는 이동 생성자로, 그렇게 하지 않았을 때는 복사 생성자로 유도되는 것을 볼 수 있습니다.

출처: https://en.cppreference.com/w/cpp/utility/move

std::move 함수는 해당 object가 이동할 수 있음을 암시만 합니다.

즉, 이동 생성자 또는 이동 할당 연산자가 선언되어 있지 않다면 이동이 아닌 복사를 수행할 수도 있다는 겁니다.

무조건 이동을 보장하지는 않는다는 것이지요.

그래서 위의 MyClass에서 이동 생성자와 이동 할당 연산자를 제거하면 std::move함수를 호출해도 복사만 수행하게 됩니다.

#include <iostream>
#include <string>

class MyClass
{
public:
    /**
     * @brief   Copy constructor (문자열 복사)
     * @param   pszName     복사할 문자열
     */
    MyClass(const char* pszName)
    {
        m_nLength = static_cast<int>(::strlen(pszName));
        m_pszName = new char[m_nLength + 1];
        ::strcpy_s(m_pszName, m_nLength + 1, pszName);

        std::cout << "문자열 복사 생성자: " << m_pszName << std::endl;
    }

    /**
     * @brief   Copy constructor
     * @param   cls         복사 대상인 데이터
     */
    MyClass(const MyClass& cls)
    {
        m_nLength = cls.m_nLength;
        m_pszName = new char[m_nLength + 1];
        ::strcpy_s(m_pszName, m_nLength + 1, cls.m_pszName);

        std::cout << "복사 생성자: " << m_pszName << std::endl;
    }

    /**
     * @brief   Deconstructor
     */
    ~MyClass()
    {
        delete[] m_pszName;
        m_pszName = nullptr;
    }

    void Release()
    {
        delete[] m_pszName;
        m_pszName = nullptr;
    }

private:
    int m_nLength;      // 문자열 길이
    char* m_pszName;    // 문자열 데이터 (new 하는 데이터로 소멸자에서 제거 예정)
};


int main(void)
{
    MyClass cls1("Hello");              // 문자열 복사 생성자
    MyClass clsCopy = cls1;             // 복사 생성자
    MyClass clsMove = std::move(cls1);  // 복사 생성자 (이동 생성자가 없으므로)

    return 0;
}

[C#, Winform] Cross Thread(UI Thread) 처리, InvokeRequired

Eskeptor — Sun, 26 May 2024 13:32:12 +0900

C#을 사용하여 GUI를 Visual Studio를 사용하여 구성하는 방법에는 크게 Winform(윈폼)과 WPF 두가지가 존재합니다.

WPF는 Dispatcher Checker를 사용하여 UI Thread가 아닌 다른 Thread를 판단한다면

Winform의 경우에는 InvokeRequired를 사용하여 UI Thread가 아닌 다른 Thread에서 접근하려고 하는지 판단합니다.

InvokeRequired

해당 Property는 System.Windows.Forms.Control에 정의된 Property로, 해당 컨트롤이 UI Thread 이외의 Thread에서 컨트롤에 접근하려고 할 때 Invoke 혹은 BeginInvoke를 사용해야하는지 유무를 반환하는 Property입니다.

즉, UI Thread 이외의 Thread에서 해당 컨트롤에 접근할 때 Invoke, BeginInvoke 호출을 해야한다고 알려주는 플래그 입니다.

InvokeRequired를 사용하지 않고 접근할 때

위의 스크린샷은 TimeTaskFunc 라는 Task에서 수행하는 함수에서 lblTime 이라는 LabelControl의 속성값인 Text에 접근하려고 하여 예외인 System.InvalidOperationException이 발생하였습니다.

UI Thread가 아닌 다른 Thread(Task)에서 UI 컨트롤을 접근하려고 하여 이러한 문제가 발생한 것입니다.

InvokeRequired를 사용하기

lblTime에 InvokeRequired값을 확인하여 BeginInvoke 또는 일반 접근을 하도록 변경하였습니다.

위의 코드처럼 하는 경우 보다는

public static class ExtensionClass
{
    public static void SetText(this Control ctrl, string text)
    {
        if (ctrl.InvokeRequired)
        {
            ctrl.BeginInvoke((Action)(() => ctrl.SetText(text)));
            return;
        }

        ctrl.Text = text;
    }
}

위와 같은 확장 메서드 SetText를 만들고

이렇게 많이 사용합니다.

[C#] 바이트 배열 다루기 : BitConverter

Eskeptor — Wed, 16 Aug 2023 21:48:08 +0900

C#을 다루면서 비트를 다룰 때 생각보다 많이 사용하게되는 BitConverter입니다.
데이터를 바이트 배열로 변환하거나 바이트 배열을 데이터로 변환하여 전달할 때 많이 쓰입니다.

BitConverter Class

//
// 요약:
//     Converts base data types to an array of bytes, and an array of bytes to base
//     data types.
public static class BitConverter

BitConverter는 static class의 형태로 내부의 함수들 또한 static 함수로 이루어져 있습니다.

BitConverter에서 자주 쓰이는 함수 (데이터를 Byte 배열로 변환)

// bool 값을 byte[]로 변환
public static byte[] GetBytes(bool value);
    bool bValue = true;
    byte[] bytes = BitConverter.GetBytes(bValue); // 0x01

// char 값을 byte[]로 변환
public static byte[] GetBytes(char value);
    char ch = 'A';
    byte[] bytes = BitConverter.GetBytes(ch);     // 0x0041
    
// short 값을 byte[]로 변환
public static byte[] GetBytes(short value);
    short sNum = short.MaxValue;
    byte[] bytes = BitConverter.GetBytes(sNum);   // 0x7FFF

// ushort 값을 byte[]로 변환
public static byte[] GetBytes(ushort value);
    ushort usNum = ushort.MaxValue - 10;
    byte[] bytes = BitConverter.GetBytes(usNum);  // 0xFFF5

// int 값을 byte[]로 변환
public static byte[] GetBytes(int value);
    int nNum = 21883746;
    byte[] bytes = BitConverter.GetBytes(nNum);   // 0x014DEB62

// uint 값을 byte[]로 변환
public static byte[] GetBytes(uint value);
    uint unNum = 12345678;
    byte[] bytes = BitConverter.GetBytes(unNum);  // 0x00BC614E

// long 값을 byte[]로 변환
public static byte[] GetBytes(long value);
    long lNum = 6892731L;
    byte[] bytes = BitConverter.GetBytes(lNum);   // 0x0000000000692CBB

// ulong 값을 byte[]로 변환
public static byte[] GetBytes(ulong value);
    ulong ulNum = 483719208173UL;
    byte[] bytes = BitConverter.GetBytes(ulNum);  // 0x000000709FE95CED

// float 값을 byte[]로 변환
public static byte[] GetBytes(float value);
    float fNum = 123.456f;
    byte[] bytes = BitConverter.GetBytes(fNum);   // 0x42F6E979

// double 값을 byte[]로 변환
public static byte[] GetBytes(double value);
    double dNum = 3.141592;
    byte[] bytes = BitConverter.GetBytes(dNum);   // 0x400921FAFc8B007A

BitConverter 에서 자주 쓰이는 함수 (Byte 배열을 자료형 데이터 변환)

// byte[]를 bool형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static bool ToBoolean(byte[] value, int startIndex);
    bool bValue = BitConverter.ToBoolean(bytes, 0);

// byte[]를 char형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static char ToChar(byte[] value, int startIndex);
    char ch = BitConverter.ToChar(bytes, 0);

// byte[]를 short형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static short ToInt16(byte[] value, int startIndex);
    short sNum = BitConverter.ToInt16(bytes, 0);

// byte[]를 ushort형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static ushort ToUInt16(byte[] value, int startIndex);
    ushort usNum = BitConverter.ToUInt16(bytes, 0);

// byte[]를 int형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static int ToInt32(byte[] value, int startIndex);
    int nNum = BitConverter.ToInt32(bytes, 0);

// byte[]를 uint형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static uint ToUInt32(byte[] value, int startIndex);
    uint unNum = BitConverter.ToUInt32(bytes, 0);

// byte[]를 long형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static long ToInt64(byte[] value, int startIndex);
    long lNum = BitConverter.ToInt64(bytes, 0);

// byte[]를 ulong형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static ulong ToUInt64(byte[] value, int startIndex);
    ulong lNum = BitConverter.ToUInt64(bytes, 0);

// byte[]를 float형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static float ToSingle(byte[] value, int startIndex);
    float fNum = BitConverter.ToSingle(bytes, 0);

// byte[]를 double형 데이터로 (startIndex는 value의 변환 시작 인덱스)
public static double ToDouble(byte[] value, int startIndex);
    double dNum = BitConverter.ToDouble(bytes, 0);

Big Endian과 Little Endian

Big Endian과 Little Endian은 위와 같다는 것을 우리는 알고 있습니다.

그럼 현재 프로그램을 구동하고 있는 PC의 Endian 형태는 어떻게 알 수 있을까요?

BitConverter는 IsLittleEndian 이라는 필드를 제공하고 있습니다.

// This field indicates the "endianess" of the architecture.
// The value is set to true if the architecture is
// little endian; false if it is big endian.
#if BIGENDIAN
[Intrinsic]
public static readonly bool IsLittleEndian /* = false */;
#else
[Intrinsic]
public static readonly bool IsLittleEndian = true;
#endif

물론 Visual Studio를 실행하는 대다수의 컴퓨터는 LittleEndian 임으로 true를 반환 할 것입니다.

예제

BitConvert_Example.7z

0.06MB

[리뷰] HP Victus 16 단점 위주 리뷰 (빅터스 16)

Eskeptor — Sun, 23 Jul 2023 19:27:02 +0900

HP사의 보급형 게이밍 노트북 브랜드인 빅터스시리즈의 노트북을 사게 되었습니다.

(HP에는 두 가지 게이밍 브랜드가 존재하죠. Omen(오멘)과 Victus(빅터스))

이미 나온지 꽤 된 노트북이라 많은 리뷰가 있을 것이니 저는 약 4일간 사용했을 때 단점을 위주로 리뷰를 하겠습니다.

(좋은 리뷰는 많이들 하신 것 같으니)

※ 빅터스 16의 d모델 기준입니다.

(저는 Victus 16-d1121TX모델이지만 HP 에서는 16-d 모델 전체를 하나로 보고 있기 때문입니다.)

1. 윈도우 10 설치 힘듬

빅터스 16은 기본적으로 윈도우 11 지원으로 제품을 냈습니다.

그래서 윈도우 10의 드라이버를 공식적으로 지원해주지 않는데 윈도우 자체의 드라이버 업데이트 기능으로 될 것 같아서 설치해보았으나 칩셋과 무선랜 드라이버가 잡히지 않았습니다.

CPU도 인텔 12세대임으로 윈도우 11을 까는게 맞습니다.

(아마 까는 방법이 있긴 할 겁니다.... 하지만 그냥 윈도우 11을 까는게 더 나을수도)

2. 초기형 모델인 경우는 A/S 받아야 될 수도 있음

빅터스 16에는 M.2가 2개 제공됩니다.

이 중 기본 제공해주는 SSD가 꽂힌 첫 번재 슬롯이 아닌 확장형 두 번째 슬롯이 문제인데 제가 받은 모델은 그러하지 않았지만 초기형 모델의 경우 M.2 두 번째 슬롯과 그래픽 카드가 충돌한다는 문제가 있습니다.

현재 HP 코리아에서 인식하고 있는 문제로 빅터스 16을 사신 분은 꼭 확장형 슬롯에 SSD를 끼어서 문제가 있는지 없는지 확인해 보셔야 할 것 같습니다.

HP Victus 16-d1111tx (또는 빅터스 제품군) 구매자 분들께 올리는 글

안녕하세요. 요번 빅스마일데이때 노트북 5대를 추가로 질렀는데... 긴히 알려드려야 할 것 같아 간만에

m.ppomppu.co.kr

저는 이미 이 문제를 알고 사서 대비하고 있었는데 제가 산 제품은 문제가 없었습니다.

3. 스피커에서 딱 딱 소리가 남

HP 16.1인치 게이밍 노트북 PC Victus 16-d1000 RCTO 기본 모델 소프트웨어 및 드라이버 다운로드 | HP® 고

저는 HP Virtual Agent입니다. 찾고 있는 것이 무엇인지 알려주시면 해결책을 찾을 수 있도록 지원해 드리겠습니다.

support.hp.com

위의 사이트는 HP 공식 다운로드 센터 입니다.

공식 사이트에서 사운드 드라이버를 설치하고 나면 불규칙적으로 딱 딱 소리가 나게 됩니다.

(딱 딱 소리는 뭔가 튀는 듯한 소리입니다. 뭔가를 재생중이거나 재생중이지 않아도 납니다.)

이전에 타 노트북에서 경험해 본 문제라서 저는 해결을 했지만 처음 겪으신 분들은 A/S를 요청하실수도 있을 것 같습니다.

(이 문제는 타 노트북 또는 데스크탑에서도 일어나는 문제입니다.)

간단히 말씀드리자면 윈도우10 (11 포함)에서 나타나던 사운드 드라이버 충돌 관련 문제였던 걸로 기억합니다.

제가 수행한 해결 방법은

1) 먼저 HP 공식 다운로드 센터에서 HP 드라이버를 다운로드 후 설치

2) 딱딱 소리가 난다면 3번 부터 계속 진행, 딱딱 소리가 안나면 여기서 끝

3) 윈도우 설정에서 시스템 - 소리 - 모든 사운드 장치 - 속성 에서 스테레오 믹스 항목을 허용 함을 누른다.

(허용함 상태가 되면 버튼은 "허용 안 함"이 됨)

4) 윈도우 설정에서 시스템 - 소리 에서 말하기 또는 녹음 장치 선택의 항목을 스테레오 믹스로 변경

5) 이 상태에서 윈도우 업데이트를 다시 수행

※ 윈도우 업데이트를 하면서 아마 리얼텍 관련 오디오 드라이버가 새로 설치하게 될텐데 설치하고 나면 스테레오 믹스는 다시 비활성화 되며 기본 설정이 마이크 배열로 변경 될 것입니다.

※ 만약 자동 업데이트가 없다면 이 상태에서 공식 드라이버를 다시 설치해 보세요.

※ 이도저도 안되신다면 A/S 받으세요. 불규칙적으로 자주 일어나서 현상이 쉽게 발현되니 A/S센터에서 바로 인지 할겁니다.

보통 이 과정을 거치면 딱 딱 소리는 대부분 사라지게 됩니다.

4. 모니터 힌지 덜렁거림

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

보시면 압니다.

덜렁 거립니다.

바닥이 단단하게 고정된 곳이 아니라면 (예를 들어 침대 위) 흔들 흔들 할겁니다.

마치며

A/S는 HP이기에 삼성, LG는 아니더라도 타사 대비 어렵지 않습니다.
무게는 어댑터를 포함하면 약 3KG에 가까워지는데 이 정도의 게이밍 노트북에서는 그래도 흔한 경우이기에 단점으로 보지는 않았습니다.
소음은 평소 간단한 작업(웹, 영상)에는 거의 나지 않으며 무거운 작업(컴파일, 게임)시에는 비행기가 이륙합니다.
(Omen Gaming Hub에서 성능 제어를 저소음으로 하면 그래도 낫지만 조용한 환경에서는 비추입니다.)
하지만 이정도 소음은 게이밍 노트북에서는 흔하기 때문에 단점으로 크게 지적하지는 않았습니다.
파스 점수나 시네벤치는 이미 여기저기 나와있기에 따로 추가하지 않았습니다.
이 노트북은 200W 어댑터를 제공합니다.
현재 200W 충전을 지원하는 PD충전기가 없기에 PD충전은 지원하지 않습니다.
(하지만 저는 이게 단점이라고 보기가.......단점인가...?)

저는 특가로 약 85만원에 구입하였으나 정가인 110만원이었더라도 괜찮았을 것 같지만 그 가격이었다면 안샀....

(110만원 근처라면 대안이 좀 많아지는....)

제가 보기에 가장 큰 단점은 힌지가 덜렁 덜렁....

(아마 다음 세대에서는 나아지지 않을까 싶네요...)

[C#] 바이트 배열을 이용한 비트 다루기 : BitArray

Eskeptor — Sat, 15 Jul 2023 22:57:03 +0900

C#을 다루면서 비트를 다룰 때 생각보다 많이 사용하게되는 BitArray입니다.

바이트 배열을 넣어서 사용하기도 하고 비트의 개수를 넣어서 사용하기도 합니다.

BitArray 생성자

using System.Collections;    // BitArray를 사용하기 위함

// length 만큼의 길이를 가진 비트배열을 만듬 (모든 비트는 0)
public BitArray(int length);

// length 만큼의 길이를 가진 비트배열을 만들고 기본값을 defaultValue로 설정
public BitArray(int length, bool defaultValue)

// 바이트 배열을 비트배열로 만듬
// 예) bytes = byte[2] -> BitArray를 16칸 자리를 만듬
//     (BitArray[0~7] = bytes[0], BitArray[8~15] = bytes[1])
public BitArray(byte[] bytes)

// Boolean 값을 토대로 비트배열을 만듬
// 예) { false, false, true, false }을 넣으면 4비트짜리 배열을 만듬 (0100)
public unsafe BitArray(bool[] values)

BitArray는 위의 생성자를 주로 사용하게 됩니다.

위의 생성자에서 보면 BitArray는 비트 표현을 boolean으로 하게 됩니다.

0은 false, 1은 true로 표현합니다.

BitArray 메소드 - Set(Int32, Boolean)

// index 위치의 비트를 value로 설정
public void Set(int index, bool value)

// 예시
BitArray bitArray = new BitArray(8);  // 00000000 = 0
bitArray.Set(2, true);                // 00000100 = 4

BitArray 메소드 - Get(Int32)

// index 위치의 비트 값을 bool값으로 반환
public bool Get(int index)

// 예시
BitArray bitArray1 = new BitArray(new bool[] {true, false, true, false}); // 0101 = 5
bool bBit3 = bitArray1.Get(2);  // true

BitArray 메소드 - And(BitArray)

// value와 And 연산을 수행한 결과를 반환
// 단, value와 BitArray 길이는 같아야함(같지 않으면 ArgumentException)
public unsafe BitArray And(BitArray value)

// 예시
BitArray bitArray1 = new BitArray(new byte[] {21}); // 00010101
BitArray bitArray2 = new BitArray(8, true);         // 11111111
BitArray bitArrayAND = bitArray1.And(bitArray2);    // 00010101

BitArray 메소드 - Or(BitArray)

// value와 Or 연산을 수행한 결과를 반환
// 단, value와 BitArray 길이는 같아야함(같지 않으면 ArgumentException)
public unsafe BitArray Or(BitArray value)

// 예시
BitArray bitArray1 = new BitArray(new byte[] {21}); // 00010101
BitArray bitArray2 = new BitArray(8, true);         // 11111111
BitArray bitArrayOR = bitArray1.Or(bitArray2);      // 11111111

BitArray 메소드 - Xor(BitArray)

// value와 XOR 연산을 수행한 결과를 반환
// 단, value와 BitArray 길이는 같아야함(같지 않으면 ArgumentException)
public unsafe BitArray Xor(BitArray value)

// 예시
BitArray bitArray1 = new BitArray(new byte[] {21}); // 00010101
BitArray bitArray2 = new BitArray(8, true);         // 11111111
BitArray bitArrayXOR = bitArray1.Xor(bitArray2);    // 11101010

BitArray 메소드 - Not()

// 반전(NOT)을 수행한 결과를 반환
public unsafe BitArray Not()

// 예시
BitArray bitArray = new BitArray(new byte[] {21}); // 00010101
BitArray bitArrayNOT = bitArray.Not();             // 11101010

BitArray 메소드 - RightShift(Int32)

// 오른쪽으로 count만큼 시프트한 결과를 반환
public BitArray RightShift(int count)

// 예시
BitArray bitArray = new BitArray(new byte[] {21}); // 00010101
BitArray bitArrayRS = bitArray.RightShift(4);      // 00000001

BitArray 메소드 - LeftShift(Int32)

// 왼쪽으로 count만큼 시프트한 결과를 반환
public BitArray LeftShift(int count)

// 예시
BitArray bitArray = new BitArray(new byte[] {21}); // 00010101
BitArray bitArrayLS = bitArray.LeftShift(4);       // 01010000

BitArray 메소드 - CopyTo(Array, Int32)

// BitArray의 값을 array의 index 위치에 복사
// BitArray의 값을 byte 배열로 변환하는데 많이 사용함
public unsafe void CopyTo(Array array, int index)

// 예시
BitArray bitArray = new BitArray(new byte[] {21}); // 00010101
BitArray bitArrayLS = bitArray.LeftShift(4);       // 01010000

int nByteArr = bitArrayLS.Count / 8 + bitArrayLS.Count % 8; // 비트 길이 계산
byte[] bytes = new byte[nByteArr];   // bytes = new byte[1];
bitArrayLS.CopyTo(bytes, 0);         // bytes[0] = 80

BitArray 속성 - Count와 Length

BitArray에는 Count와 Length라는 속성이 있는데 둘은 같은 BitArray의 길이라는 값을 반환합니다.

대신 Count는 Get만 할 수 있고 Length는 Get, Set 둘 다 할 수 있습니다.

[C++/Console] 테트리스 만들어 보기 - 7 (자동 하강, 블럭 회전, 라인 클리어)

Eskeptor — Mon, 17 Apr 2023 19:54:27 +0900

[C++/Console] 테트리스 만들어 보기 - 6 (바닥 충돌, 블럭 랜덤 생성)

[C++/Console] 테트리스 만들어 보기 - 5 (충돌 판정 - 벽, 블럭) [C++/Console] 테트리스 만들어 보기 - 4 (플레이어(블럭) 움직임) [C++/Console] 테트리스 만들어 보기 - 3 (화면 출력에 대한 고찰) [C++/Console]

eskeptor.tistory.com

지난 시간에는 바닥 충돌, 블럭 랜덤 생성에 대해서 알아보았습니다.

오늘은 시간이 지남에 따라 자동으로 블럭이 하강하고, 스페이스바를 눌렀을 때 블럭이 회전되며, 하나의 라인을 형성하면 해당 라인을 클리어 후 점수가 올라가는 점수 시스템에 대해서 알아보겠습니다.

자동 하강

테트리스는 지정된 시간이 지나면 블럭이 아래로 하강하는 시스템을 가지고 있습니다.

이것을 구현하기 위해서는 clock 함수를 사용하여야 합니다.

#include <ctime>      // 또는 #include <time.h>

clock_t clock(void);  // 현재 시간을 반환
// clock_t는 실제로 long형

하지만 clock 함수는 실제로는 엄청 정밀하지는 않습니다.

만약 본인이 다른 프로젝트에서 정말 정밀하게 시간을 제어해야 한다면 QueryPerformanceCounter 함수를 사용하셔야 합니다.

(이 테트리스 프로젝트에서는 엄청 정밀하게 하지 않아도 되어 clock 함수를 사용합니다.)

이 clock 함수를 이용하여 마지막으로 방향키가 움직였을 때를 기준으로 1000ms를 카운트하여 아래로 한 칸씩 내려오도록 할 것입니다.

// Console Structure
struct stConsole
{
    // 생략 ..

    // Clock
    clock_t timeStart;  // 마지막 입력지점의 시간

    stConsole()
        : hConsole(nullptr), hBuffer{ nullptr, }, nCurBuffer(0)
        , rdGen(rdDevice()), rdBlockDist(0, 6), rdDirDist(CPlayer::eDirection::Dir0, CPlayer::eDirection::Dir270)
        , timeStart(clock())
    {}
};

먼저 stConsole 구조체에 timeStart 변수를 하나 선언합니다.

원래 clock_t는 ctime 혹은 time.h 헤더를 포함해야 하나 <random>을 포함하면 같이 포함됩니다.

void InputKey()
{
    int nKey = 0;

    if (_kbhit() > 0)
    {
        nKey = _getch();

        switch (nKey)
        {
            // 생략 ...
            case eKeyCode::KEY_DOWN:
            {
                if (IsMoveAvailable(0, 1))
                {
                    g_player.AddPosition(0, 1);
                    g_console.timeStart = clock();   // <-- 키 입력 기준 시간 저장
                }
                break;
            }
            // 생략 ...
        }
    }
}

이제 InputKey 함수의 KEY_DOWN 케이스에서 아래쪽으로 움직일 수 있을 때 시간을 저장하도록 합니다.

void CheckBottom()
{
    // 마지막 입력 시간에서 현재 시간을 뺌 = 진행된 시간(ms)
    clock_t ctTimeDiff = clock() - g_console.timeStart;
    
    // 1000ms가 지나지 않았다면 바로 return
    if (ctTimeDiff < 1000)
        return;

    // 1000ms 가 지났으니 현재 시간을 다시 저장
    g_console.timeStart = clock();

    if (IsMoveAvailable(0, 1))
    {
        // 아래로 한 칸 이동
        g_player.AddPosition(0, 1);
        return;
    }

    memcpy_s(g_nArrMapBackup, sizeof(int) * MAP_WIDTH * MAP_HEIGHT, g_nArrMap, sizeof(int) * MAP_WIDTH * MAP_HEIGHT);

    g_player.SetPosition(START_POS_X, START_POS_Y);
    g_player.SetBlock(RandomBlock());
    g_player.SetDirection((CPlayer::eDirection)RamdomDirection());

    g_prevPlayerData = g_player;
}

이제 CheckBottom 함수에 시간을 계산하여 해당 시간이 1000ms가 넘었을 때 자동으로 한 칸 내려오도록 함수를 변경합니다.

여기까지 수정 후 테트리스를 실행해봅시다.

이제 시간이 지났을 때 자동으로 아래로 한 칸씩 내려오는 것을 볼 수 있습니다.

또한 임의로 한 칸을 움직였을 때도 키 입력이 끝난 이후로 일정시간 이후 다시 한 칸씩 내려오는 것을 볼 수 있습니다.

블럭 회전 (스페이스 바 입력 시)

이제 스페이스 바를 눌렀을 때 블럭이 회전하도록 하여봅시다.

먼저 블럭이 회전이 가능한 지 확인하는 함수를 먼저 만들어봅시다.

bool IsRotateAvailable()
{
    // 현재 블럭을 다음 방향으로 돌렸을 때의 블럭 모양
    int* pBlock = GetRotateBlock(g_player.GetBlock(), g_player.GetNextDirection());

    // 돌린 블럭이 벽에 부딛히지 않는지 확인
    return !IsCollision(pBlock, g_player.GetCursor());
}

이제 InputKey 함수에 블럭 회전 기능을 넣어 봅시다.

void InputKey()
{
    int nKey = 0;

    if (_kbhit() > 0)
    {
        nKey = _getch();

        switch (nKey)
        {
            // 생략 ...
            case eKeyCode::KEY_SPACE:
            {
                // 블럭 회전이 가능한 경우
                if (IsRotateAvailable())
                    // 블럭을 회전 시킴
                    g_player.SetNextDirection();
                break;
            }
            // 생략 ...
        }
    }
}

이제 실행하여봅시다.

라인 클리어

라인 클리어의 경우에 실제로 한 줄이 되는 라인을 지우는 것이 아닌 해당 줄의 정보를 바로 윗줄의 정보로 덮어쓰기 하는 방식으로 진행합니다.

위의 그림처럼 라인이 채워진 부분을 기준으로 위에서 한 칸씩 덮어써지는 느낌으로 구현합니다.

라인 클리어 확인 시점을 블럭이 바닥에 닿아서 다음 블럭으로 넘어가기 전에 테트리스 맵 배열을 탐색하여 라인이 이루어졌는지 확인하도록 합니다.

bool CheckFillLine()
{
    // 현재 플레이어(블럭)의 좌표
    COORD curPos = g_player.GetCursor();
    // 라인 클리어를 해야하는지 유무
    bool bFill = true;
    // 라인 클리어를 시킬 배열의 사이즈
    int nSize = 0;
    // 라인 클리어를 해야하는지 유무
    bool bLineCleared = false;

    // 한 블럭은 4x4의 크기임으로 Y좌표로 +4까지만 확인
    for (int nY = curPos.Y; nY < curPos.Y + 4; ++nY)
    {
        bFill = true;

        for (int nX = 1; nX < MAP_WIDTH; ++nX)
        {
            //  현재 라인에서 빈 칸이 있다면 해당 라인은 클리어될 수 없음
            if (g_nArrMapBackup[nY][nX] == 0)
            {
                bFill = false;
                break;
            }
        }

        // 라인 클리어를 해야 한다면
        if (bFill &&
            nY < MAP_HEIGHT - 1)
        {
            nSize = sizeof(int) * MAP_WIDTH * (nY - 1);
            // 이전의 라인 정보를 다음 라인 정보에 옮김 (즉, 현재 라인이 지워지고 윗 라인이 아래로 내려오는 효과)
            memcpy_s(g_nArrMapBackup[2], nSize, g_nArrMapBackup[1], nSize);
            bLineCleared = true;
        }
    }

    return bLineCleared;
}

위와 같이 라인 클리어를 하는 함수를 만듭니다.

void CheckBottom()
{
    // 마지막 입력 시간에서 현재 시간을 뺌 = 진행된 시간(ms)
    clock_t ctTimeDiff = clock() - g_console.timeStart;

    // 1000ms가 지나지 않았다면 바로 return
    if (ctTimeDiff < 1000)
        return;

    // 1000ms 가 지났으니 현재 시간을 다시 저장
    g_console.timeStart = clock();

    if (IsMoveAvailable(0, 1))
    {
        // Y Move
        g_player.AddPosition(0, 1);
        return;
    }

    memcpy_s(g_nArrMapBackup, sizeof(int) * MAP_WIDTH * MAP_HEIGHT, g_nArrMap, sizeof(int) * MAP_WIDTH * MAP_HEIGHT);

    // 라인 클리어 기능 추가
    if (CheckFillLine())
    {
        g_player.AddGameScore(1);
        memcpy_s(g_nArrMap, sizeof(int) * MAP_WIDTH * MAP_HEIGHT, g_nArrMapBackup, sizeof(int) * MAP_WIDTH * MAP_HEIGHT);
    }

    g_player.SetPosition(START_POS_X, START_POS_Y);
    g_player.SetBlock(RandomBlock());
    g_player.SetDirection((CPlayer::eDirection)RamdomDirection());

    g_prevPlayerData = g_player;
}

그리고 CheckBottom 함수에 라인 클리어 기능을 넣습니다.

그리고 실행해봅니다.

이렇게 라인 클리어까지 잘 되는 것을 확인할 수 있습니다.

다음 시간이 아마 마지막이 될 것입니다.

다음 시간에는 게임 오버, 재시작, 점수화면 표시에 대해서 알아보겠습니다.

현재 까지의 진행 프로젝트 다운로드

TetrisCpp_7편.7z

0.01MB

[C++11] unordered_map

Eskeptor — Mon, 20 Mar 2023 21:57:04 +0900

최근에 스크립트형 언어 컴파일러를 만들고 있습니다.

(실시간 스크립트 변형 후 동작을 위한)

이 과정 중에서 어휘 분석기(Lexical Analyzer)를 구현하는 과정에서 이전에 한 번 써보았던 unordered_map를 사용하게되어 unordered_map을 다시 공부한 내용을 써보려고 합니다.

들어가기에 앞서

제가 공부한 내용들은 전부 아래의 링크들에서 학습 및 참고하였습니다.

A Proposal to Add Hash Tables to the Standard Library

X(i, j, n, hf, eq) X a(i, j, n, hf, eq) X Constructs an empty container with at least n buckets, using hf as the hash function and eq as the key equality predicate, and inserts elements from [i, j) into it. Average case O(N) (N is std::distance(i, j)), wor

www.open-std.org

std::unordered_map - cppreference.com

(1) (since C++11) (2) (since C++17) Unordered map is an associative container that contains key-value pairs with unique keys. Search, insertion, and removal of elements have average constant-time complexity. Internally, the elements are not sorted in any p

en.cppreference.com

unordered_map 클래스

다양한 길이의 요소 시퀀스를 제어하는 C++ 표준 라이브러리 컨테이너 클래스 'unordered_map'에 대한 API 참조입니다.

learn.microsoft.com

unordered_map이란

unordered_map은 C++ 위원회에서 만든 해시 테이블(Hash Table)을 이용하여 해시맵(Hash Map) 기능을 하는 컨테이너(Container)입니다.
(정식 도입은 C++11에서 이루어졌습니다.)
hash라는 구조체와 함께 unordered_map, unordered_set, unordered_multimap, unordered_multiset 네 가지가 도입이 되었습니다.
unordered_map은 말 그대로 "정렬되지 않은 map"입니다.
map과 동일하게 키(Key)와 요소(Element)로 이루어져 있으며 키(Key)는 중복될 수 없습니다.
평균 시간 복잡도는 O(1) 입니다.
(단, O(1)의 속도를 유지하려면 요소의 수가 증가할 수록 버킷의 수도 같이 증가해야 함(메모리의 증가))
최악의 상황인 경우에는 O(N) (N은 키의 개수)
unordered_map은 버킷(Bucket) 단위로 관리됩니다.
버킷은 단일 링크드리스트(Singly linked list)로 이루어져 있습니다.
insert(특정 위치 삽입)할 때 최대 O(N * size()) 만큼 걸리는 것으로 보아 특정 위치에 많은 삽입이 일어나는 경우에는 성능 저하 가능성이 높습니다.
#include <unordered_map> 필요합니다.
std namespace를 사용해야합니다.
(std::unordered_map)

unordered_map 생성자

// C++11
// Key       : 키 형식
// T         : 매핑 형식
// Hash      : 해시에 사용할 함수 개체 형식
// KeyEqual  : 비교에 사용할 함수 개체 형식
// Allocator : 할당자
template<
    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >
> class unordered_map;

// C++17
// Key       : 키 형식
// T         : 매핑 형식
// Hash      : 해시에 사용할 함수 개체 형식
// KeyEqual  : 비교에 사용할 함수 개체 형식
namespace pmr 
{
template <
    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>
> using unordered_map = std::unordered_map<Key, T, Hash, KeyEqual,
                            std::pmr::polymorphic_allocator<std::pair<const Key,T>>>;
}

C++11과 C++17의 차이점은 Allocator의 차이가 있습니다.

보통 Hash, KeyEqual, Allocator는 기본값을 사용하며 Key와 T만 선언하여 사용합니다.

#include <unordered_map>

int main()
{
    // 키 타입은 string, 데이터는 int
    std::unordered_map<std::string, int> umap;
    
    return 0;
}

데이터 추가 (insert)

#include <unordered_map>
#include <iostream>

int main()
{
    std::unordered_map<std::string, int> umap;
    // 방법 1
    umap.insert(std::make_pair("Hi", 11));
    // 방법 2
    umap.insert(std::unordered_map<std::string, int>::value_type("My", 22));
    // 방법 3
    umap.insert({ "Hello", 33 });
    
    return 0;
}

기본적으로 위와 같은 방법이 있습니다.

반복자 (iterator)

vector, deque 등의 컨테이너(Container)들과 마찬가지로 정방향, 역방향 반복자를 지원합니다.

#include <unordered_map>
#include <iostream>

int main()
{
    std::unordered_map<std::string, int> umap = 
    {
        std::make_pair("Hi", 1),
        std::make_pair("Hello", 3),
        std::make_pair("World", 4),
        std::make_pair("!!!", 6)
    };
    
    // 정방향
    // auto it = umap.begin(); 도 가능
    std::unordered_map<std::string, int>::iterator it = umap.begin();
    while (it != umap.end())
    {
        // Do something ...
        ++it;
    }
    
    // 역방향
    // auto cit = umap.cbegin(); 도 가능
    std::unordered_map<std::string, int>::const_iterator cit = umap.cbegin();
    while (cit != umap.cend())
    {
        // Do something ...
        ++cit;
    }
    
    // 정방향 (버킷의 크기 만큼 이동)
    // auto itb = umap.begin(umap.bucket("Hi")); 도 가능
    std::unordered_map<std::string, int>::iterator it = umap.begin(umap.bucket("Hi"));
    
    // 역방향 (버킷의 크기 만큼 이동)
    // auto citb = umap.cbegin(umap.bucket("Hi")); 도 가능
    std::unordered_map<std::string, int>::const_iterator citb = umap.cbegin(umap.bucket("Hi"));
    
    return 0;
}

버킷단위로 관리하는 만큼 버킷의 크기만큼 이동하는 반복자도 지원합니다.

데이터 삭제 (erase)

unordered_map의 erase는 map의 erase와 동일한 동작을 수행합니다.

#include <unordered_map>
#include <iostream>

int main()
{
    std::unordered_map<std::string, int> umap = 
    {
        std::make_pair("Hi", 1),
        std::make_pair("Hello", 3),
        std::make_pair("World", 4),
        std::make_pair("!!!", 6)
    };
    
    std::unordered_map<std::string, int>::iterator it = umap.begin();
    umap.erase(it);	    // { "Hi",1 }   제거
    umap.erase("!!!");  // { "!!!", 6 } 제거
    
    return 0;
}

요소 값(Element) (at, [ ])

특정 키(Key)의 요소 값(Element)을 받아오는 기능입니다.

#include <unordered_map>
#include <iostream>

int main()
{
    std::unordered_map<std::string, int> umap = 
    {
        std::make_pair("Hi", 1),
        std::make_pair("Hello", 3),
        std::make_pair("World", 4),
        std::make_pair("!!!", 6)
    };
    
    printf("Hi: %d\n", umap.at("Hi"));     // Hi: 1
    printf("Hello: %d\n", umap["Hello"]);  // Hello: 3
    umap["Hello"] = 5;
    printf("Hello: %d\n", umap["Hello"]);  // Hello: 5
    
    return 0;
}

[ ] operator의 경우에는 값을 대입할 수도 있습니다.

키(Key)의 요소 값(Element) 찾기 (find)

키(Key)의 요소 값(Element)을 찾는 기능입니다.

#include <unordered_map>
#include <iostream>

int main()
{
    std::unordered_map<std::string, int> umap = 
    {
        std::make_pair("Hi", 1),
        std::make_pair("Hello", 3),
        std::make_pair("World", 4),
        std::make_pair("!!!", 6)
    };
    
    std::unordered_map<std::string, int>::iterator it = umap.find("World");
    
    // 키값을 찾지 못했다면 iterator는 end()와 같음
    if (it != umap.end())
        printf("Find: [%s, %d]\n", it->first, it->second);  // Find: [World, 4]
    
    return 0;
}

키(Key)의 요소 개수 찾기 (count)

find()와 비슷하지만 find()는 키(Key)와 요소(Element)를 반환하는 대신에 count()는 단순히 개수만 반환합니다.

#include <unordered_map>
#include <iostream>

int main()
{
    std::unordered_map<std::string, int> umap = 
    {
        std::make_pair("Hi", 1),
        std::make_pair("Hello", 3),
        std::make_pair("World", 4),
        std::make_pair("!!!", 6)
    };
    
    // 키값을 찾으면 반환되는 개수는 1 (키값이 중복되지 않으므로 요소의 개수도 1개)
    if (umap.count("Hi") == 1)
        printf("Find: Hi");
    
    return 0;
}

실제로 libcxx에서 count()를 구현할 때 find()를 사용했다고 합니다.

unordered_map: which one is faster find() or count()?

What is the fastest way to figure out if an unordered_map container has an item with a specified key?

stackoverflow.com

요소가 비어있는지 확인 (empty), 전체 요소의 개수 (size)

다른 컨테이너(Container)에서도 제공하는 empty()와 size()입니다.

#include <unordered_map>
#include <iostream>

int main()
{
    std::unordered_map<std::string, int> umap;
    
    if (umap.empty())
        printf("umap is empty.\n");
        
    umap.insert(std::make_pair("Hi", 1));
    umap.insert(std::make_pair("Hello", 3));
    umap.insert(std::make_pair("World", 4));
    umap.insert(std::make_pair("!!!", 6));
    
    if (umap.empty() == false)
        printf("umap count: %d\n", umap.size());
    
    return 0;
}

[C++/Console] 테트리스 만들어 보기 - 6 (바닥 충돌, 블럭 랜덤 생성)

Eskeptor — Mon, 6 Mar 2023 20:30:20 +0900

[C++/Console] 테트리스 만들어 보기 - 5 (충돌 판정 - 벽, 블럭)

[C++/Console] 테트리스 만들어 보기 - 4 (플레이어(블럭) 움직임) [C++/Console] 테트리스 만들어 보기 - 3 (화면 출력에 대한 고찰) [C++/Console] 테트리스 만들어 보기 - 2 (키보드 입력 및 블럭) [C++/Console]

eskeptor.tistory.com

지난 시간에는 충돌 판정에 관련하여 알아보았습니다.

오늘은 바닥 충돌(또는 블럭 충돌) 및 블럭 랜덤 생성에 대해서 알아보겠습니다.

바닥 충돌 (또는 블럭 충돌)

지난 시간에 이어서 바닥에 충돌하였을 때 감지하는 방법을 알아봅시다.

바닥을 확인하는 CheckBottom 함수를 작성합니다.

void CheckBottom()
{
    if (IsMoveAvailable(0, 1))
        return;

    // 다음 줄로 움직일 수 없다면 현재 블럭을 포함하여 맵에 저장
    memcpy_s(g_nArrMapBackup, sizeof(int) * MAP_WIDTH * MAP_HEIGHT, g_nArrMap, sizeof(int) * MAP_WIDTH * MAP_HEIGHT);

    // 플레이어의 위치를 초기 위치로 변경
    g_player.SetPosition(START_POS_X, START_POS_Y);
    // 플레이어의 블럭 설정
    g_player.SetBlock(1);
    // 플레이어의 블럭 방향 설정
    g_player.SetDirection(CPlayer::eDirection::Dir0);

    g_prevPlayerData = g_player;
}

이 CheckBottom 함수는

int main(void)
{
    InitGame();

    while (true)
    {
        InputKey();
        CalcPlayer();

        CheckBottom();        // <-- Player가 움직인 이후에 바닥 확인
        Render(3, 1);

        ClearScreen();
        BufferFlip();
        Sleep(1);
    }

    DestroyGame();

    return 0;
}

CalcPlayer 함수 다음에 수행합니다.

(플레이어가 움직인 이후에 바닥을 확인하는 매커니즘입니다.)

이렇게 수정하고 실행하게 되면

이렇게 바닥 또는 더 이상 내려가지 못하는 곳으로 가게 되면 다음 블럭으로 넘어가게 됩니다.

랜덤 블럭 생성

이제 블럭을 랜덤으로 생성할 수 있도록 코드를 작성하여 봅시다.

그 전에 C++에서 사용하는 랜덤 함수에 대해서 알아봅시다.

크게 2가지가 있습니다.

// C언어 기반 rand 함수 사용
#include <stdlib.h>         // 랜덤 함수(srand, rand)가 있는 헤더 파일
#include <time.h>           // 시간 함수(time)가 있는 헤더 파일

srand(time(NULL));          // 랜덤 시드 설정 (time(NULL)은 1970.1.1의 시간 값을 반환)
int nRand = rand() % 10;    // 0 ~ 9까지 랜덤 값을 반환

C언어 기반의 랜덤 함수와

// C++11 기반의 랜덤 함수 (MT19937 사용)
#include <random>               // 랜덤 함수가 들어있는 헤더파일

std::random_device rdDevice;    // 랜덤 시드용 디바이스
std::mt19937 gen(rdDevice());   // 난수 생성 엔진(메르센 트위스터) 초기화
std::uniform_int_distribution<int> dist(0, 9);   // 0 ~ 9 랜덤 값 생성
int nRandom = dist(gen);        // 랜덤 값 생성

C++11에서 제공하는 랜덤 함수가 있습니다.

이 방법들 중 후자의 방법(C++11 기반)을 사용하도록 하겠습니다.

먼저 stConsole 구조체에 랜덤 관련 변수를 추가합니다.

// Console Structure
struct stConsole
{
    // 생략 ....

    // Random Seed
    random_device rdDevice;
    // Random Generation
    mt19937 rdGen;
    // Random Distribution (블럭)
    uniform_int_distribution<int> rdBlockDist;
    // Random Distribution (블럭의 방향)
    uniform_int_distribution<int> rdDirDist;

    stConsole()
        : hConsole(nullptr), hBuffer{ nullptr, }, nCurBuffer(0)
        , rdGen(rdDevice()), rdBlockDist(0, 6), rdDirDist(CPlayer::eDirection::Dir0, CPlayer::eDirection::Dir270)
    {}
};

그리고 랜덤으로 블럭을 생성하는 RandomBlock 함수와 랜덤으로 블럭의 방향을 생성하는 RandomDirection 함수를 작성합니다.

/**
블럭 랜덤 생성
*/
int RandomBlock()
{
    return g_console.rdBlockDist(g_console.rdGen);
}

/**
블럭의 방향 랜덤 생성
*/
int RamdomDirection()
{
    return g_console.rdDirDist(g_console.rdGen);
}

이제 모든 상황에서 블럭을 랜덤한 방향으로 생성하도록 해봅시다.

// InitGame 함수 변경
void InitGame(bool bInitConsole = true)
{
    // Initialize Player Data
    {
        g_player.SetPosition(START_POS_X, START_POS_Y);
        g_player.SetXPositionRange(-1, MAP_WIDTH);
        g_player.SetYPositionRange(0, MAP_HEIGHT);
        
        // 블럭 랜덤 생성
        g_player.SetBlock(RandomBlock());
        // 블럭 방향 랜덤 생성
        g_player.SetDirection((CPlayer::eDirection)RamdomDirection());
        
        g_player.SetGameScore(0);
        g_player.SetGameOver(false);

        g_prevPlayerData = g_player;
    }
    
    // 생략 ....
}

InitGame 함수에서 블럭을 랜덤으로 생성하도록 변경 합니다.

// CheckBottom 함수 변경
void CheckBottom()
{
    if (IsMoveAvailable(0, 1))
        return;

    memcpy_s(g_nArrMapBackup, sizeof(int) * MAP_WIDTH * MAP_HEIGHT, g_nArrMap, sizeof(int) * MAP_WIDTH * MAP_HEIGHT);

    g_player.SetPosition(START_POS_X, START_POS_Y);
    // 블럭 랜덤 생성
    g_player.SetBlock(RandomBlock());
    // 블럭 방향 랜덤 생성
    g_player.SetDirection((CPlayer::eDirection)RamdomDirection());

    g_prevPlayerData = g_player;
}

CheckBottom 함수에서 블럭을 랜덤으로 생성하도록 변경 합니다.

이제 실행하여 봅시다.

이렇게 바닥 또는 블럭에 충돌했을 때 다음 블럭으로(랜덤하게) 나오도록 하였습니다.

다음 시간에는 자동으로 블럭이 내려오도록 하고 라인을 형성하였을 때 지워지면서 점수가 올라가도록 해보겠습니다.

현재 까지의 진행 프로젝트 다운로드

TetrisCpp_6편.7z

0.01MB

[C++/Console] 테트리스 만들어 보기 - 5 (충돌 판정 - 벽, 블럭)

Eskeptor — Mon, 20 Feb 2023 20:44:13 +0900

[C++/Console] 테트리스 만들어 보기 - 4 (플레이어(블럭) 움직임)

[C++/Console] 테트리스 만들어 보기 - 3 (화면 출력에 대한 고찰) [C++/Console] 테트리스 만들어 보기 - 2 (키보드 입력 및 블럭) [C++/Console] 테트리스 만들어 보기 - 1 (간단 소개 및 더블 버퍼링) Window 환

eskeptor.tistory.com

지난 시간에는 플레이어(블럭)의 움직임에 관련하여 알아보았습니다.

오늘은 플레이어(블럭) 충돌 판정에 대해서 알아보겠습니다.

충돌 판정

지난 시간에 했던 프로젝트를 실행해서 움직여보면 좌, 우, 하단 끝에 도달하여도 계속 가는 것을 볼 수 있습니다.

이것을 방지하기 위해서는 충돌 판정을 통해서 움직이지 못하도록 해야합니다.

그럼 어떻게 하면 충돌 판정을 시킬 수 있을 까요?

void InputKey()
{
    int nKey = 0;

    if (_kbhit() > 0)
    {
        nKey = _getch();

        switch (nKey)
        {
            case eKeyCode::KEY_UP:
            {
                break;
            }
            case eKeyCode::KEY_DOWN:
            {
                g_player.AddPosition(0, 1);    // <-- 움직이기
                break;
            }
            case eKeyCode::KEY_LEFT:
            {
                g_player.AddPosition(-1, 0);   // <-- 움직이기
                break;
            }
            case eKeyCode::KEY_RIGHT:
            {
                g_player.AddPosition(1, 0);    // <-- 움직이기
                break;
            }
            case eKeyCode::KEY_SPACE:
            {
                break;
            }
            case eKeyCode::KEY_R:
            {
                break;
            }
        }
    }
}

현재 우리는 InputKey 함수에서 키를 누름과 동시에 플레이어(블럭)의 좌표를 증가하도록 하였습니다.

그래서 누름과 동시에 이동을 하게 됩니다.

그럼 좌표를 증가시키기 전에 그 위치로 이동해도 되는지 확인하는 과정(충돌을 하는지 안하는지)을 거치게 되면 벽을 넘어서지 못하도록 할 수 있습니다.

먼저 이전 맵의 데이터를 기록하는 배열을 전역으로 하나 만듭니다.

// Map Data (Backup Data)
int g_nArrMapBackup[MAP_HEIGHT][MAP_WIDTH] = { 0, };

이제부터 이 배열은 이전의 테트리스 맵을 백업하도록 할겁니다.

(이전이라고 함은 현재 블럭이 ㄴ 이고 이전 블럭이 ㅡ 일 때 ㄴ 블럭 이전의 맵 데이터)

그리고 충돌을 확인하는 IsCollision 함수를 작성합니다.

// pBlock : 블럭 데이터
// coordPlayer : 블럭의 위치
bool IsCollision(int* pBlock, const COORD& coordPlayer)
{
    int nColision = 0;

    for (int nY = 0; nY < BLOCK_HEIGHT; ++nY)
    {
        for (int nX = 0; nX < BLOCK_WIDTH; ++nX)
        {
            // 벽 충돌 유무
            nColision = pBlock[(nY * BLOCK_HEIGHT) + nX] & (g_nArrMapBackup[coordPlayer.Y + nY][coordPlayer.X + nX] << 1);
            // 다른 블럭과 충돌 유무
            nColision += pBlock[(nY * BLOCK_HEIGHT) + nX] & g_nArrMapBackup[coordPlayer.Y + nY][coordPlayer.X + nX];

            // 벽 또는 블럭과 충돌 했다면 충돌로 판정
            if (nColision > 0)
                return true;
        }
    }

    return false;
}

그리고 IsCollision 함수를 이용하여 키가 눌렸을 때 그 위치로 이동할 수 있는지 유무를 판단하는 함수인 IsMoveAvailable 함수를 작성합니다.

// nXAdder : 플레이어(블럭)이 이동할 X 위치(증가)
// nYAdder : 플레이어(블럭)이 이동할 Y 위치(증가)
bool IsMoveAvailable(int nXAdder, int nYAdder)
{
    // 현재 플레이어의 위치
    COORD coorNext = g_player.GetCursor();
    // 다음 위치를 미리 시뮬레이션
    coorNext.X += nXAdder;
    coorNext.Y += nYAdder;
    // 다음 위치로 이동한 블럭의 데이터
    int* pBlock = GetRotateBlock(g_player.GetBlock(), g_player.GetDirection());

    // 다음 위치로 이동 했을 때 충돌을 했는지 유무
    return !IsCollision(pBlock, coorNext);
}

이제 IsMoveAvailable 함수를 이용하여 충돌 감지하여 벽을 벗어나지 못하도록 해봅시다.

void InputKey()
{
    int nKey = 0;

    if (_kbhit() > 0)
    {
        nKey = _getch();

        switch (nKey)
        {
            case eKeyCode::KEY_UP:
            {
                break;
            }
            case eKeyCode::KEY_DOWN:
            {
                if (IsMoveAvailable(0, 1))
                    g_player.AddPosition(0, 1);
                break;
            }
            case eKeyCode::KEY_LEFT:
            {
                if (IsMoveAvailable(-1, 0))
                    g_player.AddPosition(-1, 0);
                break;
            }
            case eKeyCode::KEY_RIGHT:
            {
                if (IsMoveAvailable(1, 0))
                    g_player.AddPosition(1, 0);
                break;
            }
            case eKeyCode::KEY_SPACE:
            {
                break;
            }
            case eKeyCode::KEY_R:
            {
                break;
            }
        }
    }
}

그리고 이전의 테트리스 맵을 기억하는 백업용 배열을 초기화 합시다.

void InitGame(bool bInitConsole = true)
{
    // Initialize Player Data
    {
        // 생략 ......
    }

    if (bInitConsole)
    {
        // 생략 ......
    }

    // Map Backup
    {
        int nMapSize = sizeof(int) * MAP_WIDTH * MAP_HEIGHT;
        memcpy_s(g_nArrMap, nMapSize, ORIGIN_MAP, nMapSize);
        memcpy_s(g_nArrMapBackup, nMapSize, g_nArrMap, nMapSize);  // <-- 백업맵 초기화
    }
}

이제 실행하여 봅시다.

이렇게 벽에 닿으면 더이상 움직이지 않게 되었습니다.

다음 시간에는 블럭이 바닥에 닿았을 때 해당 블럭은 바닥에 남고 다음 블럭이 랜덤으로 생성되는 것에 대해서 알아보도록 하겠습니다.

현재 까지의 진행 프로젝트 다운로드

TetrisCpp_5편.7z

0.01MB

[C++/Console] 테트리스 만들어 보기 - 4 (플레이어(블럭) 움직임)

Eskeptor — Thu, 9 Feb 2023 22:21:33 +0900

[C++/Console] 테트리스 만들어 보기 - 3 (화면 출력에 대한 고찰)

[C++/Console] 테트리스 만들어 보기 - 2 (키보드 입력 및 블럭) [C++/Console] 테트리스 만들어 보기 - 1 (간단 소개 및 더블 버퍼링) Window 환경에서 C++과 Console창을 이용하여 테트리스를 만들어 봅시다.

eskeptor.tistory.com

지난 시간에는 화면 출력에 관련하여 알아보았습니다.

오늘은 플레이어(블럭) 움직이는 처리에 대해서 알아보겠습니다.

플레이어(블럭) 클래스

먼저 플레이어(블럭)의 처리를 도와줄 클래스를 작성하여봅시다.

class CPlayer
{
public:
    // Block 방향
    enum eDirection
    {
        Dir0 = 0,
        Dir90,
        Dir180,
        Dir270,

        DirMax
    };

private:   
    int m_nXPos;               // 현재 X 위치
    int m_nMinXPos;            // 움직일 수 있는 최소 X 범위
    int m_nMaxXPos;            // 움직일 수 있는 최대 X 범위
    int m_nYPos;               // 현재 Y 위치
    int m_nMinYPos;            // 움직일 수 있는 최소 Y 범위
    int m_nMaxYPos;            // 움직일 수 있는 최대 Y 범위
    int m_nCurBlock;           // 현재 블록 (인덱스 값)
    eDirection m_eDirection;   // 현재 블록의 방향
    int m_nGameScore;          // 점수
    bool m_bIsGameOver;        // 게임 오버 유무

public:
    /**
    @brief        생성자
    */
    CPlayer(int nXPos = 0, int nYPos = 0, int nCurBlock = 0, eDirection eDir = eDirection::Dir0)
        : m_nXPos(nXPos), m_nYPos(nYPos), m_nCurBlock(nCurBlock), m_eDirection(eDir)
        , m_nMinXPos(0), m_nMinYPos(0), m_nMaxXPos(20), m_nMaxYPos(20)
        , m_nGameScore(0), m_bIsGameOver(false)
    {}

    /**
    @brief        X 위치 범위 설정
    @param        nMinXPos    최소 X 범위
    @param        nMaxXPos    최대 X 범위
    @return
    */
    inline void SetXPositionRange(int nMinXPos, int nMaxXPos)
    {
        m_nMinXPos = nMinXPos;
        m_nMaxXPos = nMaxXPos;
    }

    /**
    @brief        Y 위치 범위 설정
    @param        nMinYPos    최소 Y 범위
    @param        nMaxYPos    최대 Y 범위
    @return
    */
    inline void SetYPositionRange(int nMinYPos, int nMaxYPos)
    {
        m_nMinYPos = nMinYPos;
        m_nMaxYPos = nMaxYPos;
    }

    /**
    @brief        현재 위치 설정
    @param        nXPos        현재 X 위치
    @param        nYPos        현재 Y 위치
    @return
    */
    inline void SetPosition(int nXPos, int nYPos)
    {
        m_nXPos = nXPos;
        m_nYPos = nYPos;
    }

    /**
    @brief        현재 X 위치 설정
    @param        nXPos        현재 X 위치
    @return
    */
    inline void SetXPosition(int nXPos) { m_nXPos = nXPos; }

    /**
    @brief        현재 Y 위치 설정
    @param        nYPos        현재 Y 위치
    @return
    */
    inline void SetYPosition(int nYPos) { m_nYPos = nYPos; }

    /**
    @brief        현재 블록의 방향 설정
    @param        eDir         현재 블록의 방향
    @return
    */
    inline void SetDirection(eDirection eDir) { m_eDirection = eDir; }

    /**
    @brief        현재 블록의 방향을 다음 방향으로 변경 (ex: 90도 -> 180도)
    @param
    @return
    */
    inline void SetNextDirection()
    {
        m_eDirection = m_eDirection + 1 >= eDirection::DirMax ? eDirection::Dir0 : (eDirection)(m_eDirection + 1);
    }

    /**
    @brief        점수 설정
    @param        nScore        점수
    @return
    */
    inline void SetGameScore(int nScore) { m_nGameScore = nScore; }

    /**
    @brief        현재 점수에서 더하는 기능
    @param        nAdder        더할 점수
    @return
    */
    inline void AddGameScore(int nAdder)
    {
        m_nGameScore = m_nGameScore + nAdder >= 0 ? m_nGameScore + nAdder : 0;
    }

    /**
    @brief        게임 오버 설정
    @param        bIsGameOver        게임 오버 상태
    @return
    */
    inline void SetGameOver(bool bIsGameOver) { m_bIsGameOver = bIsGameOver; }

    /**
    @brief        현재 위치에서 더하는 기능
    @param        nXAdder        X 위치 증가값
    @param        nYAdder        Y 위치 증가값
    @return
    */
    inline void AddPosition(int nXAdder, int nYAdder)
    {
        m_nXPos = (m_nXPos + nXAdder >= m_nMinXPos) ? (m_nXPos + nXAdder <= m_nMaxXPos ? m_nXPos + nXAdder : m_nMaxXPos) : m_nMinXPos;
        m_nYPos = (m_nYPos + nYAdder >= m_nMinYPos) ? (m_nYPos + nYAdder <= m_nMaxYPos ? m_nYPos + nYAdder : m_nMaxYPos) : m_nMinYPos;
    }

    /**
    @brief        현재 블럭을 설정 (인덱스 값)
    @param        nBlock        현재 블럭 (인덱스 값)
    @return
    */
    inline void SetBlock(int nBlock) { m_nCurBlock = nBlock; }

    /**
    @brief        현재 X 위치 반환
    @param        
    @return       현재 X 위치
    */
    inline int GetXPosition() const { return m_nXPos; }

    /**
    @brief        현재 Y 위치 반환
    @param
    @return       현재 Y 위치
    */
    inline int GetYPosition() const { return m_nYPos; }
    
    /**
    @brief        현재 블럭 반환 (인덱스 값)
    @param
    @return       현재 블럭 (인덱스 값)
    */
    inline int GetBlock() const { return m_nCurBlock; }
    
    /**
    @brief        현재 블럭의 방향 반환
    @param
    @return       현재 블럭의 방향
    */
    inline eDirection GetDirection() const { return m_eDirection; }

    /**
    @brief        현재 블럭의 다음 방향 반환
    @param
    @return       현재 블럭의 다음 방향
    */
    inline eDirection GetNextDirection() const
    {
        return (m_eDirection + 1 >= eDirection::DirMax) ? eDirection::Dir0 : (eDirection)(m_eDirection + 1);
    }

    /**
    @brief        현재 위치 반환 (COORD형)
    @param
    @return       현재 위치 (COORD형)
    */
    inline COORD GetCursor() const
    {
        COORD cursor{ (SHORT)m_nXPos, (SHORT)m_nYPos };
        return cursor;
    }

    /**
    @brief        점수 반환
    @param
    @return       점수
    */
    inline int GetGameScore() const { return m_nGameScore; }

    /**
    @brief        게임 오버 상태 반환
    @param
    @return       게임 오버 상태
    */
    inline bool GetGameOver() const { return m_bIsGameOver; }

    CPlayer& operator=(CPlayer& player)
    {
        m_nXPos = player.m_nXPos;
        m_nYPos = player.m_nYPos;
        m_nCurBlock = player.m_nCurBlock;
        m_eDirection = player.m_eDirection;
        m_nMinXPos = player.m_nMinXPos;
        m_nMinYPos = player.m_nMinYPos;
        m_nMaxXPos = player.m_nMaxXPos;
        m_nMaxYPos = player.m_nMaxYPos;

        return *this;
    }

    friend bool operator==(const CPlayer& player1, const CPlayer& player2)
    {
        return (player1.m_nXPos == player2.m_nXPos) &&
            (player1.m_nYPos == player2.m_nYPos) &&
            (player1.m_nCurBlock == player2.m_nCurBlock) &&
            (player1.m_eDirection == player2.m_eDirection) &&
            (player1.m_nMinXPos == player2.m_nMinXPos) &&
            (player1.m_nMinYPos == player2.m_nMinYPos) && 
            (player1.m_nMaxXPos == player2.m_nMaxXPos) &&
            (player1.m_nMaxYPos == player2.m_nMaxYPos);
    }

    friend bool operator!=(const CPlayer& player1, const CPlayer& player2)
    {
        return !(player1 == player2);
    }
};

자세한 설명들은 소스에 있으니 읽어보시면 이해가 될 겁니다.

이 플레이어(블럭)를 전역으로 선언합니다.

// Player Data
CPlayer g_player;

키보드 입력 처리

[C++/Console] 테트리스 만들어 보기 - 2 (키보드 입력 및 블럭)

[C++/Console] 테트리스 만들어 보기 - 1 (간단 소개 및 더블 버퍼링) Window 환경에서 C++과 Console창을 이용하여 테트리스를 만들어 봅시다. 명령 프롬프트의 환경설정 테트리스에서 사용하는 특수 문

eskeptor.tistory.com

기본적인 키보드 입력에 관련한 처리는 2번 챕터에서 알아보았었습니다.

void InputKey()
{
    int nKey = 0;

    // 키입력이 감지되었을 때
    if (_kbhit() > 0)
    {
        // 입력된 키를 받아온다.
        nKey = _getch();

        switch (nKey)
        {
            case eKeyCode::KEY_UP:    // 방향키 위를 눌렀을 때
            {
                break;
            }
            case eKeyCode::KEY_DOWN:  // 방향키 아래를 눌렀을 때
            {
                break;
            }
            case eKeyCode::KEY_LEFT:  // 방향키 왼쪽을 눌렀을 때
            {
                break;
            }
            case eKeyCode::KEY_RIGHT: // 방향키 오른쪽을 눌렀을 때
            {
                break;
            }
            case eKeyCode::KEY_SPACE: // 스페이스바를 눌렀을 때
            {
                break;
            }
            case eKeyCode::KEY_R:     // R키를 눌렀을 때
            {
                break;
            }
        }
    }
}

이렇게 InputKey 함수를 작성하였었습니다.

여기에 플레이어(블럭)의 좌표를 움직이도록 함수를 추가합니다.

void InputKey()
{
    int nKey = 0;

    if (_kbhit() > 0)
    {
        nKey = _getch();

        switch (nKey)
        {
            case eKeyCode::KEY_UP:
            {
                // 나중에 블럭 바로 내리기에 사용
                break;
            }
            case eKeyCode::KEY_DOWN:
            {
                // 아래로 1칸 이동 (Y좌표로 1증가)
                g_player.AddPosition(0, 1);
                break;
            }
            case eKeyCode::KEY_LEFT:
            {
                // 왼쪽으로 1칸 이동 (X좌표로 1감소)
                g_player.AddPosition(-1, 0);
                break;
            }
            case eKeyCode::KEY_RIGHT:
            {
                // 오른쪽으로 1칸 이동 (X좌표로 1증가)
                g_player.AddPosition(1, 0);
                break;
            }
            case eKeyCode::KEY_SPACE:
            {
                // 나중에 블럭 회전에 사용
                break;
            }
            case eKeyCode::KEY_R:
            {
                // 나중에 초기화에 사용
                break;
            }
        }
    }
}

이렇게 플레이어(블럭)의 이동을 구현하였습니다.

이제 Render 함수와 CalcPlayer를 변경해야합니다.

이전에는 고정된 위치에 플레이어(블럭)를 그렸다면 지금은 플레이어(블럭)의 실시간 위치에 맞게 그리도록 변경해야합니다.

void CalcPlayer()
{
    // 현재 플레이어(블럭) 위치를 받아온다.
    COORD playerCursor = g_player.GetCursor();

    // 현재 블럭의 방향에 따른 모양을 받아온다.
    int* pBlock = GetRotateBlock(g_player.GetBlock(), g_player.GetDirection());
    for (int nY = 0; nY < BLOCK_HEIGHT; ++nY)
    {
        for (int nX = 0; nX < BLOCK_WIDTH; ++nX)
        {
            if (pBlock[(nY * BLOCK_HEIGHT) + nX])
                g_nArrMap[playerCursor.Y + nY][playerCursor.X + nX] = pBlock[(nY * BLOCK_HEIGHT) + nX];
        }
    }
}

여기서 GetRotateBlock라는 함수를 사용하였습니다.

현재 블럭의 방향에 따라서 블럭의 모양을 반환하는 함수로 반환 값은 일차원배열로 나옵니다.

// 블럭 데이터 (전역 변수)
int* g_pCurBlock = nullptr;

// nBlockIdx : 블럭의 인덱스
// eDir : 블럭의 방향
int* GetRotateBlock(int nBlockIdx, CPlayer::eDirection eDir)
{
    // 이전 블럭의 데이터가 있다면 제거
    if (g_pCurBlock != nullptr)
    {
        delete[] g_pCurBlock;
        g_pCurBlock = nullptr;
    }

    // 새로운 블럭 할당
    g_pCurBlock = new int[BLOCK_HEIGHT * BLOCK_WIDTH];
    int nMemSize = sizeof(int) * BLOCK_HEIGHT * BLOCK_WIDTH;
    memcpy_s(g_pCurBlock, nMemSize, BLOCKS[nBlockIdx], nMemSize);

    // 블럭 회전
    for (int nRot = 0; nRot < (int)eDir; ++nRot)
    {
        int nTemps[BLOCK_HEIGHT * BLOCK_WIDTH] = { 0, };

        for (int nY = 0; nY < BLOCK_HEIGHT; ++nY)
        {
            for (int nX = 0; nX < BLOCK_WIDTH; ++nX)
            {
                nTemps[(nX * BLOCK_WIDTH) + (BLOCK_HEIGHT - nY - 1)] = g_pCurBlock[(nY * BLOCK_HEIGHT) + nX];
            }
        }

        memcpy_s(g_pCurBlock, nMemSize, nTemps, nMemSize);
    }

    return g_pCurBlock;
}

void DestroyGame()
{
    // 블럭 데이터 제거
    if (g_pCurBlock != nullptr)
    {
        delete[] g_pCurBlock;
        g_pCurBlock = nullptr;
    }

    if (g_console.hBuffer[0] != nullptr)
    {
        CloseHandle(g_console.hBuffer[0]);
    }

    if (g_console.hBuffer[1] != nullptr)
    {
        CloseHandle(g_console.hBuffer[1]);
    }
}

전역으로 블럭 데이터를 가지고 있을 포인터g_pCurBlock를 선언 합니다.

해당 포인터는 DestroyGame 함수에서 제거할 것입니다.

이제 InitGame 함수에 플레이어(블럭)의 초기 값을 넣어줍시다.

void InitGame(bool bInitConsole = true)
{
    // 플레이어(블럭) 데이터 초기화
    {
        // START_POS_X = 4
        // START_POS_Y = 1
        g_player.SetPosition(START_POS_X, START_POS_Y);
        g_player.SetXPositionRange(-1, MAP_WIDTH);
        g_player.SetYPositionRange(0, MAP_HEIGHT);
        g_player.SetBlock(1);    // J 블럭
        g_player.SetDirection(CPlayer::eDirection::Dir0);
        g_player.SetGameScore(0);
        g_player.SetGameOver(false);
    }

    // 콘솔 데이터 초기화
    if (bInitConsole)
    {
        // 생략 ...
    }

    // 맵 데이터 초기화
    {
        int nMapSize = sizeof(int) * MAP_WIDTH * MAP_HEIGHT;
        memcpy_s(g_nArrMap, nMapSize, ORIGIN_MAP, nMapSize);
    }
}

이제 메인 함수에 InputKey 함수를 추가하고 실행하여봅시다.

int main(void)
{
    InitGame();

    while (true)
    {
        // 키 입력 함수
        InputKey();
        CalcPlayer();

        Render(3, 1);

        ClearScreen();
        BufferFlip();
        Sleep(1);
    }

    DestroyGame();
    return 0;
}

하지만 실행을 하면

일단 문제점은 2가지 입니다.

잔상이 남음
Frame을 넘어서 그림이 그려짐

먼저 첫번째 문제를 해결하여 봅시다.

잔상이 남는 문제 해결

현재 우리는 버퍼를 이용하여 새롭게 변경된 부분에만 그림을 그리고 있기 때문에 기존의 잔상이 남습니다.

해결 방법은 이전의 플레이어(블럭) 위치를 기억하여 위치를 변경할 때 마다 이전 위치를 Clear 시키고 현재 위치에 그림을 그리도록 하면 됩니다.

이전 위치를 기억하도록 하기 위한 플레이어(블럭) 객체를 하나 더 전역으로 선언합니다.

// 플레이어(블럭) 데이터 (전역 변수)
CPlayer g_player;
// 이전 위치를 기억할 플레이어(블럭) 데이터 (전역 변수)
CPlayer g_prevPlayerData;

이제 InitGame 함수에 이전 위치 기록용 플레이어(블럭) 데이터를 초기화 해줍시다.

void InitGame(bool bInitConsole = true)
{
    // 플레이어(블럭) 데이터 초기화
    {
        // START_POS_X = 4
        // START_POS_Y = 1
        g_player.SetPosition(START_POS_X, START_POS_Y);
        g_player.SetXPositionRange(-1, MAP_WIDTH);
        g_player.SetYPositionRange(0, MAP_HEIGHT);
        g_player.SetBlock(1);    // J 블럭
        g_player.SetDirection(CPlayer::eDirection::Dir0);
        g_player.SetGameScore(0);
        g_player.SetGameOver(false);
        
        // 플레이어(블럭) 데이터를 이전 위치 기록용 데이터에 초기 데이터로 설정
        g_prevPlayerData = g_player;
    }

    // 생략 ...
}

이제 CalcPlayer 함수를 변경하여줍니다.

void CalcPlayer()
{
    COORD playerCursor = g_player.GetCursor();

    // 이전 위치의 블럭 제거 코드
    // (이전 위치과 현재 위치가 다른 경우)
    if (g_prevPlayerData != g_player)
    {
        // 이전 위치의 블럭데이터를 가져옴
        int* pBlock = GetRotateBlock(g_prevPlayerData.GetBlock(), g_prevPlayerData.GetDirection());
        COORD sprevCursor = g_prevPlayerData.GetCursor();

        for (int nY = 0; nY < BLOCK_HEIGHT; ++nY)
        {
            for (int nX = 0; nX < BLOCK_WIDTH; ++nX)
            {
                // 이전 위치의 블럭이 위치한 좌표의 데이터를 지워줌
                if (pBlock[(nY * BLOCK_HEIGHT) + nX] &&
                    pBlock[(nY * BLOCK_HEIGHT) + nX] == g_nArrMap[sprevCursor.Y + nY][sprevCursor.X + nX])
                    g_nArrMap[sprevCursor.Y + nY][sprevCursor.X + nX] = 0;
            }
        }

        // 현재 플레이어(블럭)의 정보를 이전 정보에 기록
        g_prevPlayerData = g_player;
    }

    int* pBlock = GetRotateBlock(g_player.GetBlock(), g_player.GetDirection());
    for (int nY = 0; nY < BLOCK_HEIGHT; ++nY)
    {
        for (int nX = 0; nX < BLOCK_WIDTH; ++nX)
        {
            if (pBlock[(nY * BLOCK_HEIGHT) + nX])
                g_nArrMap[playerCursor.Y + nY][playerCursor.X + nX] = pBlock[(nY * BLOCK_HEIGHT) + nX];
        }
    }
}

그리고 실행하여 봅시다.

Frame을 넘어서 그림이 그려지는 문제 해결

이 문제는 우리가 그림을 그리는 방식때문에 일어나는 현상입니다.

이러한 상황인 것이죠.

이 부분을 해결하기 위해서는 Render 함수를 변경하여야합니다.

void Render(int nXOffset = 0, int nYOffset = 0)
{
    COORD coord{ 0, };
    int nXAdd = 0;
    DWORD dw = 0;

    for (int nY = 0; nY < MAP_HEIGHT; ++nY)
    {
        // 한 라인에 그려지는 블록의 개수
        int nBlockCount = 0;
        nXAdd = 0;

        for (int nX = 0; nX < MAP_WIDTH; ++nX)
        {
            coord.X = nXAdd + nXOffset;
            coord.Y = nY + nYOffset;

            SetConsoleCursorPosition(g_console.hBuffer[g_console.nCurBuffer], coord);
            WriteFile(g_console.hBuffer[g_console.nCurBuffer], BLOCK_TYPES[g_nArrMap[nY][nX]], sizeof(BLOCK_TYPES[g_nArrMap[nY][nX]]), &dw, NULL);

            // 1칸 증가
            ++nXAdd;

            // 공백의 경우에는 2칸이 1칸을 이룸(공백 2칸이 문자 한 칸과 같은 넓이를 이룸)
            if (g_nArrMap[nY][nX] == 0)
                ++nXAdd;
            // 블럭의 개수를 셈
            else
                ++nBlockCount;
        }

        // 벗어난 부분 덧칠하기            
        if (nY > 0 &&
            nY < MAP_HEIGHT - 1)
        {
            // 프레임이 끝나는 지점을 계산
            int nStart = nXOffset + nBlockCount + (MAP_WIDTH - nBlockCount) * 2;
            for (int nX = 0; nX < nBlockCount; ++nX)
            {
                coord.X = nStart + nX;
                SetConsoleCursorPosition(g_console.hBuffer[g_console.nCurBuffer], coord);
                WriteFile(g_console.hBuffer[g_console.nCurBuffer], BLOCK_TYPES[0], sizeof(BLOCK_TYPES[0]), &dw, NULL);
            }
        }
    }
}

이제 실행을 해봅시다.

이제 잔상도 제거되었고 Frame 외부에 그려지는 현상도 제거하였습니다.

다음 시간에는 플레이어(블럭)의 충돌 판정에 대해서 알아봅시다.

현재 까지의 진행 프로젝트 다운로드

TetrisCpp.7z

0.01MB