백구 게임개발 스터디

5/8 (코드카타)

백구 — Fri, 8 May 2026 12:13:40 +0900

#include <string>
#include <vector>

using namespace std;

string solution(string phone_number) {
    string answer = phone_number;
    
    for (int i = 0; i < answer.size() - 4; i++) {
        answer[i] = '*';
    }
    
    return answer;
}

코드카타 전화번호 가리기코드

class의 정의

class Student
{
    //동작 정의(이를 멤버함수라고 합니다)
    double getAvg();
    int getMaxNum();
    
    //데이터 정의(이를 멤버변수라고 합니다.)
    int kor[3];
    int eng[3];
    int math[3];
};

멤버함수 구현(클래스 내부)

#include <iostream>
#include <algorithm> //max 함수 사용
#include <string>
using namespace std;
class Student
{
    //동작 정의(이를 멤버함수라고 합니다)
    double getAvg()
    {
        return (kor + eng + math ) / 3.0; 
    }
    int getMax()
    {
        return max(max(kor, eng), math); 
    }
    
    //데이터 정의(이를 멤버변수라고 합니다.)
    int kor;
    int eng;
    int math;
};

멤버함수 구현(클래스 내부)

#include <iostream>
#include <algorithm> //max 함수 사용
#include <string>
using namespace std;
class Student
{
    //동작 정의(이를 멤버함수라고 합니다)
    double getAvg();
    int getMaxNum();
    //데이터 정의(이를 멤버변수라고 합니다.)
    int kor;
    int eng;
    int math;
};

double Student::getAvg()
{
    return (kor + eng + math) / 3.0;
}
int Student::getMaxNum()
{
    return max(max(kor, eng), math);
    // 다른 방법 return max({ kor, eng, math });
}

접근제어

private에 접근제어

#include <iostream>
#include <algorithm> //max 함수 사용
#include <string>
using namespace std;

class Student
{
    //동작 정의(이를 멤버함수라고 합니다)
    double getAvg();
    int getMaxScore();
    //데이터 정의(이를 멤버변수라고 합니다.)
    int kor;
    int eng;
    int math;
};

double Student::getAvg()
{
    return (kor + eng + math) / 3.0;
}

int Student::getMaxScore()
{
    return max(max(kor, eng), math);
}

int main()
{
    Student s;
    s.getAvg();
    
    return 0;
}

public,private으로 접근제어

#include <iostream>
#include <algorithm> //max 함수 사용
#include <string>
using namespace std;

class Student
{
public:
    //동작 정의(이를 멤버함수라고 합니다)
    double getAvg();
    int getMaxScore();

private:
    //데이터 정의(이를 멤버변수라고 합니다.)
    int kor;
    int eng;
    int math;
};

double Student::getAvg()
{
    return (kor + eng + math) / 3.0;
}

int Student::getMaxScore()
{
    return max(max(kor, eng), math);
}

int main()
{
    Student s;
    s.getAvg();
    
    return 0;
}

클래스의 멤버 함수나 멤버 변수에 접근할 때는 객체 뒤에 멤버 접근 연산자 .을 사용합니다.

또한, 클래스는 접근 지정자를 사용하여 멤버의 접근 권한을 제어할 수 있습니다.

getter와 setter를 적용한 clss

#include <iostream>
#include <algorithm> //max 함수 사용
#include <string>

using namespace std;

class Student
{
public:
    //동작 정의(이를 멤버함수라고 합니다)
    double getAvg();
    int getMaxScore();

	    void setMathScore(int math)
    {
        this->math = math;
    }
    void setEngScore(int eng)
    {
        this->eng = eng;
  
    }
    void setKorScore(int kor)
    {
        this->kor = kor;
    }

    int  getMathScore() { return math; }
    int  getEngScore() { return eng; }
    int  getKorScore() { return kor; }

private:
    //데이터 정의(이를 멤버변수라고 합니다.)
    int kor;
    int eng;
    int math;
};

double Student::getAvg()
{
    return (kor + eng + math) / 3.0;
}

int Student::getMaxScore()
{
    return max(max(kor, eng), math);
}

int main()
{
    Student s;

    s.setEngScore(32);
    s.setKorScore(52);
    s.setMathScore(74);

    //평균 최대점수 출력
    cout << s.getAvg() << endl;
    cout << s.getMaxScore() << endl;

    return 0;
}

그후 과제2가 끝난 팀원들과 팀프로젝트 기획과 실습을 하였습니다

5/7 (코드카타)

백구 — Thu, 7 May 2026 16:36:23 +0900

#include <string>
#include <vector>

using namespace std;

int solution(vector<int> absolutes, vector<bool> signs) {
    int answer = 0;
    
    for (int i = 0; i < absolutes.size(); i++) {
        if (signs[i]) {
            answer += absolutes[i];
        } else {
            answer -= absolutes[i];
        }
    }
    
    return answer;
}  // 배열안에 절대값이있고 true면양수 false면 음수 모두 더한값 출력

강의 포인터와 레퍼런스

일반변수에서 대입 연산 =를 하면 변수에 있는 값이 그대로 복사됩니다.

하나의 변수를 다른 변수에 대입하면 새로운 메모리 공간에 동일한 값이 복제됩니다.

따라서 복사 이후에 두 변수는 서로 독립적인 공간을 가지므로, 한 쪽 값을 변경해도 다른쪽에는 영향이 없습니다.

하지만 복사비용이 있습니다.

배열의 크기가 커지면 복사 비용이 꽤 부담스러울 수 있습니다.

이러한 복사비용 때문에 C++에서는 값을 직접 복사하는 방식 대신 변수의 주소를 가리켜서 동일한 데이터에 접근할 수 있도록 할 수 있게 해줍니다.

포인터의 모든 연산은 주소값과 관련되어 있습니다.

A=B를 하면 B에있는 값이 A변수에 그대로 저장됩니다.

값이 아닌 주소값의 정보를 제공하겠다는 것을 알려줘야 합니다.

이때 사용하는 연산자가 &입니다.

A=B가 아닌,A=&B를 하게 되면 A에 B의 주소값이 들어갑니다.

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int* p = &a; // 변수 a의 주소를 포인터 p에 저장

    cout << "변수 a의 값: " << a << endl;
    cout << "변수 a의 주소: " << &a << endl;
    cout << "포인터 p의 값(저장된 주소): " << p << endl;

    return 0;
}

/*
출력 결과:
변수 a의 값: 10
변수 a의 주소: 0x61ff08 (주소는 실행할 때마다 다를 수 있음)
포인터 p의 값(저장된 주소): 0x61ff08
*/

포인터 변수의 역참조

포인터는 주소를 다루는 특성 떄문에 산술 연산 역시 주소를 제어하는 방식으로 동작합니다.

이를 위해 역참조 연산자 *를 사용합니다.

A를 출력하면 주소값이 나오고, *A를 출력하면 해당 메모리에 있는 값이 나옵니다.

#include <iostream>
using namespace std;

int main() {
    int x = 3;    // 정수형 변수 x 선언
    int* ptr = &x; // 포인터 ptr에 x의 주소 저장

    cout << "x의 값: " << x << endl;
    cout << "x의 주소: " << &x << endl;
    cout << "ptr의 값(저장된 주소): " << ptr << endl;
    cout << "*ptr이 가리키는 값: " << *ptr << endl;

    return 0;
}

/*
출력 결과:
x의 값: 3
x의 주소: 0x61ff00 (주소는 실행할 때마다 다름)
ptr의 값(저장된 주소): 0x61ff00
*ptr이 가리키는 값: 3
*/

배열과 포인터의 차이

배열의 이름은 사용될 때 대부분 포인터로 암시적 형 변환되어 동작합니다.

ex) in arr[4];가 있을 때 arr은 배열 전체를 의미합니다.

하지만 식이나 인자로 사용되면 int*형으로 변환되어 배열의 첫번째 원소 주소로 해석됩니다.

#include <iostream>
using namespace std;

// 레퍼런스를 활용하여 변수에 별명을 부여하는 예제
int main() {
    int var = 10;
    int& ref = var; // var의 레퍼런스 선언

    cout << "초기 값:" << endl;
    cout << "var: " << var << endl; // 10
    cout << "ref: " << ref << endl; // 10

    ref = 20; // ref를 변경하면 var도 변경됨

    cout << "ref 값을 변경한 후:" << endl;
    cout << "var: " << var << endl; // 20
    cout << "ref: " << ref << endl; // 20

    return 0;
}

/*
출력 결과:
초기 값:
var: 10
ref: 10
ref 값을 변경한 후:
var: 20
ref: 20
*/

레퍼런스

포인터를 사용하면 주소값을 직접 다루어야 하므로 복잡해질 수 있습니다.

이 문제를 완화하기 위해 C++에서는 변수에 또 다른 이름을 부여하는 'fpvjfjstm'문법을 도입했습니다.

레퍼런스는 일반 변수와 거의 동일하게 사용할 수 있습니다.

그러나 내부적으로는 해당 변수를 직접 가리켜 주는 역할을 합니다.

포인터와 레퍼런스의 차이점

1.선언과 초기화 시점이 다릅니다.

-포인터는 선언 후, 나중에 =연산자를 통해 가리킬 대상을 변경할 수 있습니다.

반면에 레퍼런스는 선언과 동시에 초기화해야 하며,

초기화 이후에는 다른 대상에 재연결할 수 없습니다.

2.레퍼런스는 항상 다른 변수와 연결되어 있기 때문에 NULL이라는 게 없습니다.

-반면에 포인터는 유효한 대상이 없음을 나타내기 위해 NULL 혹은 nullptr을 가질 수 있습니다.

3.간접 참조 문법의 유무입니다.

-포인터는 주소값을 담으므로 접근할 때는 *연산을 사용하고 주소를 가져올 때는 &연산을 사용합니다.

하지만 레퍼런스는 변수 자체의 별명이므로 일반변수와 연산하는 방법이 동일합니다.

텍스트던전rpg 분석

백구 — Wed, 6 May 2026 20:15:06 +0900

#include

#include <iostream> // cout, cin, endl
#include <string>   // string 문자열 자료형
#include <vector>   // vector 동적 배열
#include <algorithm>// sort, min
#include <map>      // key-value 저장소

using namespace std;

using namespace std;

// std를 안썼을때
std::cout << "hello";
std::string name;

// std를 썼을때
cout << "hello";
string name;

C++ 표준 라이브러리의 기능들은 원래 std::cout, std::string처럼 써야 함.
그런데 이 문장을 쓰면 std::를 생략할 수 있음.

템플릿 template<typename T> — 자료형을 일반화

template<typename T> //여기서 T는 “아직 정해지지 않은 타입”.
class Inventory
{
    ...
};

Inventory<Item> inventory(10); // 예시코드

템플릿은 자료형을 나중에 정하게 하는 문법.

이걸 통해 하나의 클래스로 여러 타입을 처리하는 방법을 알수잇음.

클래스 class - 사용자 정의 자료형

class Player
{
protected:
    string name;
    string job;
    int level;
    int exp;
    int maxExp;
    int hp;
    int mp;
    int power;
    int defence;
    ...
};

클래스는 데이터와 기능을 하나로 묶는 문법

데이터: 이름, 직업, HP, MP, 공격력
기능: 공격, 상태 출력, getter, setter

접근 지정자 private, protected, public

private: // 클래스 내부에서만 사용
    T* pItems;
    int capacity_;
    int size_;

protected: // 클래스 내부 + 자식 클래스
    string name;
    string job;

public: // 외부에서도 사용 가능
    Player(string name, int hp, int mp, int power, int defence)

Inventory 내부 배열은 외부가 함부로 건드리면 안 되니까 private
Player의 이름/직업은 자식 클래스(전사, 궁수)가 써야 하니까 protected
생성자, getter, setter는 외부에서 써야 하니까 public

생성자 - 객체가 만들어질 때 자동 실행

Player(string name, int hp, int mp, int power, int defence)
{
    this->name = name;
    this->job = "None";
    this->level = 1;
    this->exp = 0;
    this->maxExp = 100;
    this->hp = hp;
    this->mp = mp;
    this->power = power;
    this->defence = defence;
}

생성자는 객체를 만들 때 자동으로 호출되는 함수야.

역할

플레이어 객체가 만들어지면:

이름 저장
초기 직업 설정
레벨 1 설정
경험치 0 설정
기본 스탯 저장

이런 초기화 작업을 해줌.

this-> -- 현재 객체 자신 가리키기

this->name = name;
this->hp = hp;

this는 현재 객체 자신을 가리키는 포인터.

매개변수 이름과 멤버변수 이름이 같아서 구분하려고 씀.

상속 : public Player

class Warrior : public Player
{
public:
    Warrior(string name, int hp, int mp, int power, int defence)
        : Player(name, hp, mp, power, defence)
    {
        job = "전사";
        this->hp += 30;
    }

    void attack(Monster* monster) override;
};

상속은 기존 클래스의 기능을 물려받아 새 클래스를 만드는 문법.

생성자 초기화 리스트 : Player(...)

Warrior(string name, int hp, int mp, int power, int defence)
    : Player(name, hp, mp, power, defence)
{
    ...
}

자식 클래스가 만들어질 때, 먼저 부모 클래스 생성자를 호출하는 문법.

전사를 만들기 전에 먼저 Player 부분을 초기화하고,
그 다음에 전사 전용 설정을 추가한다.

가상 함수와 순수 가상 함수

virtual void attack(Monster* monster) = 0;

순수 가상 함수.
부모 클래스에서는 형태만 정하고, 구현은 자식이 꼭 하게 만드는 문법.

Player는 “플레이어는 공격할 수 있다”는 틀만 제공하고,
실제 공격 방식은 전사/마법사/도적/궁수가 각자 구현.

오버라이딩 override

void attack(Monster* monster) override;  // 예시코드

void Archer::attack(Monster* monster)
{
    int damage = (power - monster->getDefence()) / 3;
    ...
}

오버라이딩은 부모 클래스의 함수를 자식 클래스가 다르게 다시 구현.

전사: 한 번 강하게
마법사: 한 번 강하게
궁수: 3번 나눠 때림
도적: 5번 나눠 때림

같은 attack인데 행동이 다르다.

전방 선언 class Monster;

class Monster;

이건 “Monster라는 클래스가 뒤에 나올 거다”라고 미리 이름만 알려주는 문법.

왜 필요한가?

virtual void attack(Monster* monster) = 0;

player 안에서 위의 코드가있음

그런데 Monster 클래스 정의는 뒤쪽에 있기때문에
컴파일러에게 “Monster라는 타입이 나중에 나와”라고 미리 알려줘야 한다.

포인터 T*, Player*, Monster*

T* pItems;  // 아이템 배열의 시작 주소
Player* player = nullptr; // 플레이어 객체를 가리키는 주소
virtual void attack(Monster* monster) = 0; // 몬스터 객체를 가리키는 주소

포인터는 메모리 주소를 저장하는 변수.

동적 메모리 할당
함수에 원본 객체 전달
부모 포인터로 자식 객체 다루기

동적 메모리 new, delete[], delete

pItems = new T[capacity_];
delete[] pItems;


player = new Warrior(name, stat[0], stat[1], stat[2], stat[3]);
...
delete player;

프로그램 실행중에 메모리를 직접 만들고 해제하는 문법.

new T[capacity_] : 배열 생성
delete[] pItems : 배열 해제
new Warrior(...) : 객체 1개 생성
delete player : 객체 1개 해제

소멸자 ~Inventory()

~Inventory()
{
    delete[] pItems;
}

소멸자는 객체가 사라질 때 자동 호출되는 함수.

Inventory가 사라질 때 내부에서 new[]로 만든 메모리를 정리한다.

복사 생성자

Inventory(const Inventory& other)
{
    capacity_ = other.capacity_;
    size_ = other.size_;
    pItems = new T[capacity_];

    for (int i = 0; i < size_; i++)
    {
        pItems[i] = other.pItems[i];
    }
}

복사 생성자는 객체를 복사해서 새 객체를 만들 때 호출되는 함수.

Inventory는 내부에 포인터 pItems가 있어서,
그냥 복사하면 주소만 복사되는 얕은 복사 문제가 생길 수 있음.

그래서 새 메모리를 만들고, 안의 값들을 직접 복사해야함.

배열과 인덱스

int stat[SIZE] = { 0 };
cout << "HP: " << stat[0] << "     MP: " << stat[1] << endl;
cout << "공격력: " << stat[2] << "     방어력: " << stat[3] << endl;

배열은 같은 타입의 데이터를 순서대로 저장하는 구조.

함수 매개변수와 반환값

int GetStock(map<string, int>& potionStock, string name)
{
    return potionStock[name];
}

함수는 입력을 받고 결과를 돌려줄 수 있음.

참조 & 와 포인터 * 차이

// 예시1
int GetStock(map<string, int>& potionStock, string name)
// 예시2
void setPotion(int count, int* p_HPPotion, int* p_MPPotion)
{
    *p_HPPotion = count;
    *p_MPPotion = count;
}

둘 다 원본에 접근할 수 있지만 다르다.

참조 & : 원본의 다른 이름처럼 사용
포인터 * : 주소를 받아서 역참조해서 사용

둘다나오는 이유

map은 참조로 넘겨서 편하게 수정/조회
포션 숫자는 포인터로 넘겨서 주소 개념 연습

getter / setter

int getHP()
{
    return hp;
}

void setHP(int hp)
{
    this->hp = hp;
}

클래스 내부 데이터를 직접 열어두지 않고,
함수를 통해 읽고 수정하는 방법.

외부가 내부 구조를 직접 건드리지 않음
나중에 검증 로직 추가 가능
캡슐화 강화

구조체 struct

struct Item
{
    string name;
    int price;

    void PrintInfo() const
    {
        cout << name << " (" << price << "G)" << endl;
    }
};

// 또는

struct PotionRecipe
{
    string potionName;
    string ingredient1;
    string ingredient2;
};

구조체는 관련 있는 데이터를 묶는 자료형.
C++에서는 함수도 넣을 수 있어서 class와 비슷하게 쓸 수 있음.

Item : 아이템 정보
PotionRecipe : 포션 레시피 정보
DungeonRoom : 방 정보

const - 수정 금지 약속

void PrintInfo() const

void ShowAllRecipes(const vector<PotionRecipe>& recipes)

const는 “이걸 수정하지 않겠다”는 약속이야.

PrintInfo() const : 이 함수는 객체의 멤버값을 바꾸지 않음
const vector<PotionRecipe>& : recipes를 읽기만 하고 수정하지 않음

vector — 동적 배열

vector<PotionRecipe> recipes;
recipes.push_back({ "HP포션", "허브", "맑은물" });

vector는 크기가 자동으로 늘어나는 배열.

포션 레시피 개수가 고정이 아니어도 편하게 추가할 수 있음.

map<string, int> — key-value 자료구조

map<string, int> potionStock;

potionStock["HP 포션"] = 3;
potionStock["MP 포션"] = 3;

map은 이름표(key) 와 값(value) 를 짝으로 저장하는 자료구조.

반복문 for, while

for (int i = 0; i < size_; i++)
{
    pItems[i] = other.pItems[i];
}


while (true)
{
    ...
}

for : 횟수가 명확할 때
while : 조건이 참인 동안 반복할 때

예시

for : 인벤토리 복사, 배열 출력, 방 순회
while : 게임 메뉴 반복, 전투 반복, 입력 검증

조건문 if, else if, switch

if (damage <= 0)
{
    damage = 1;
}


switch (jobChoice)
{
case 1:
    player = new Warrior(...);
    break;
...
}

조건에 따라 분기하는 문법이야.

if : 범위, 비교, 복합 조건에 강함
switch : 번호 선택 메뉴에 적합

sort, min — 알고리즘 함수

sort(pItems, pItems + size_, compareByPrice);

int newHP = min(player->getHP() + 50, 100);

표준 라이브러리 알고리즘을 직접 사용하는 방법이야.

sort : 정렬
min : 둘 중 작은 값

예시

아이템 가격순 정렬
HP/MP가 최대값을 넘지 않게 제한

5/6 (개인프로젝트,과제2도전step8)

백구 — Wed, 6 May 2026 17:35:54 +0900

주말과 남은시간을 모두 사용해서 게임개발을 하였습니다

https://youtu.be/_Tymr6o0sO8

step1

포인터를 이용해 함수 바깥 변수 값을 변경하는 방법을 연습했다

setPotion(int count, int* p_HPPotion, int* p_MPPotion) 함수를 만들어 HP 포션과 MP 포션 개수를 한 번에 설정했다.

&변수는 주소를 뜻한다.
*포인터는 해당 주소가 가리키는 실제 값이다.
함수 밖 변수 값을 바꾸려면 포인터나 참조를 사용해야 한다.

step2

이번 단계에서는 Player 클래스에 레벨, 경험치, 최대 경험치 개념을 추가했다.

exp, maxExp, level을 관리하도록 만들고, 전투 승리 시 경험치를 획득하도록 구현했다.
경험치가 최대 경험치 이상이 되면 레벨업이 발생하고, 레벨업 시 HP, MP, 공격력이 증가하도록 연결했다.

step3

이번 단계에서는 오버라이딩을 활용해 직업마다 다른 공격 방식을 구현했다.

기존 attack() 함수를 virtual void attack(Monster* monster) = 0; 형태로 바꾸고,
전사 / 마법사 / 궁수 / 도적이 각각 자기 방식대로 공격하도록 재정의했다.

직업별 공격 방식:

전사: 공격력 - 방어력, 1회 공격
마법사: 공격력 - 방어력, 1회 공격
궁수: (공격력 - 방어력) / 3 데미지를 3번 적용
도적: (공격력 - 방어력) / 5 데미지를 5번 적용

step4

이번 단계에서는 전투 중 플레이어가 공격 또는 아이템 사용을 선택할 수 있도록 시스템을 확장했다.

플레이어 턴에 메뉴를 출력하고:

공격
아이템 사용

중 하나를 선택하게 만들었다.
아이템 사용을 고르면 인벤토리를 보여주고, 선택한 포션에 따라 HP 또는 MP를 회복시켰다.

회복량은 50으로 설정했고, min()을 사용해 최대치를 넘지 않게 처리했다.

예시:

HP 포션 사용 → player->setHP(min(player->getHP() + 50, 100));
MP 포션 사용 → player->setMP(min(player->getMP() + 50, 100));

step5

이번 단계에서는 vector<Item> 대신 직접 만든 템플릿 인벤토리 클래스를 구현했다.

template<typename T> 형태로 Inventory<T>를 만들고, 내부에:

T* pItems
int capacity_
int size_

를 두었다.

생성자에서 new T[capacity_]로 메모리를 할당하고,
소멸자에서 delete[] pItems를 호출해 메모리를 정리했다.

추가한 주요 함수:

AddItem
RemoveLastItem
RemoveAt
PrintAllItems
GetSize
GetCapacity
GetItem

또한 복사 생성자를 구현해서 깊은 복사를 적용했다.

step6

이번 단계에서는 인벤토리가 꽉 찼을 때 자동으로 늘어나는 Resize 기능과, 가격순 정렬 기능을 추가했다.

Resize(int newCapacity)를 구현해:

새 배열 생성
기존 데이터 복사
기존 배열 해제
새 배열 연결

순서로 처리했다.

그리고 AddItem()에서 공간이 부족하면 자동으로 Resize(capacity_ * 2)를 호출하도록 만들었다.

정렬 기능은 compareByPrice(const Item& a, const Item& b) 비교 함수를 만들고,
SortItems()에서 std::sort(pItems, pItems + size_, compareByPrice)를 사용해 구현했다.

step7

이번 단계에서는 map<string, int>를 이용해 포션 재고 시스템을 구현했다.

포션 이름을 key, 재고 수량을 value로 저장했다.

step8

이번 단계에서는 단순 1회 전투가 아니라, 여러 방을 순서대로 클리어한 뒤 보스방이 열리는 구조를 만들었다.

DungeonRoom 구조체를 만들어 각 방의 정보를 저장했다.

구조체에 포함한 정보:

몬스터 이름
HP
공격력
방어력
드랍 아이템 이름
드랍 아이템 가격
경험치 보상

이후 vector<DungeonRoom>로 일반 방 3개를 만들고,
for문으로 순서대로 클리어하도록 했다.

4/30(코드카타)

백구 — Thu, 30 Apr 2026 21:34:44 +0900

나누어 떨어지는 수

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

vector<int> solution(vector<int> arr, int divisor) {
    vector<int> answer;
    
    for (int i = 0; i < arr.size(); i++) {
        if (arr[i] % divisor == 0) {
            answer.push_back(arr[i]);
        }
    }
    
    if (answer.empty()) {
        answer.push_back(-1);
    } else {
        sort(answer.begin(), answer.end());
    }
    
    return answer;
}

알고리즘 해더를 안넣으면 sort를 못넣는걸 알았다.

개인프로젝트 진행 점프

공격 밀치기 구현

던전탈출rpg과제 총정리+학습

백구 — Wed, 29 Apr 2026 16:15:27 +0900

게임의 전체 흐름

1.이름입력

2.hp,mp,공격력,방어력 총 입력

3.입력값 검사

4.캐릭터강화

6.직업 선택

7.던전입장

8.몬스터 전투

9.승리 시 아이템 획득

10.인벤토리 저장

11.인벤토리 확인 /포션제작/게임종료

사용한 헤더 파일

#include <iostream> cout,cin,endl 사용
#include <string> string 사용
#include <vector> vector<Item>, vector<PotionRecipe> 사용

Step1

string name;

int stat[SIZE] = {0};

으로 입력받기

배열구조

stat[0] = HP
stat[1] = MP
stat[2] = 공격력
stat[3] = 방어력

Step2

입력 유효성 검사

잘못된 값을 입력하면 다시 입력받기 위해 와일문 사용

while (true)
{
    if (stat[0] >= 50 && stat[1] >= 50)
    {
        break;
    }
    cout << "다시 입력해주세요." << endl;
}

Step3

게임 시작전에 강화

while (!isGameStart)
{
switch (choice)
    {
    case 1:
        stat[0] += 20;
        hpPotion--;
        break;
    case 0:
        isGameStart = true;
        break;
    }
}

Step4

개체지향시작

class Player
{
protected: // 자식 클래스에서는 접근 가능하지만, main같은 외부에서는 접근할 수 없다
    string name;
    string job;
    int level;
    int hp;
    int mp;
    int power;
    int defence;
};

==>

job = "전사";
this->hp += 30;

player->hp; // 불가능

순수가상함수와 오버라이딩 //중요하다고 생각함

virtual void attack() = 0;

Player는 attack이라는 함수가 반드시 있어야 한다.
하지만 Player가 직접 공격 방식을 정하지 않는다.
자식 클래스가 반드시 구현해야 한다.

void attack() override
{
cout << "* 파이어볼을 발사한다!" << endl;
}

순수 가상 함수는 부모의 강제 규칙, 오버라이딩은 자식의 실제 구현.

player포인터,다형성

Player* player = nullptr;
player = new Magician(name, stat[0], stat[1], stat[2], stat[3]);

플레이어 직업이 여러개이기 때문에 포인터를 씀

player = new Warrior(...);
player = new Magician(...);
player = new Thief(...);
player = new Archer(...);

->와.차이

player->getName();
monster.getName();

포인터는 화살표 ->, 일반 객체는 점 .

Step5

getter / setter

getter // 값을 읽는 함수

int getHP()
{
return hp;
}

setter // 값을 바꾸는 함수

void setHP(int hp)
{
this->hp = hp;
}

전투 while문

while (player->getHP() > 0 && monster.getHP() > 0)

플레이어와 몬스터가 둘 다 살아 있는 동안 전투 반복.

Step6

Item 구조체

struct Item
{
    string name;
    int price;
    void PrintInfo() const
    {
        cout << name << " (" << price << "G)" << endl;
    }
};

인벤토리

vector<Item> inventory;

Item들을 여러 개 저장할 수 있는 동적 배열.

Step7

포션 제작소와 레시피 검색

PotionRecipe 구조체

struct PotionRecipe
{
...
};

vector<PotionRecipe> recipes;//레시피 저장

핵심

for (const PotionRecipe& recipe : recipes) recipes안에 레시피를 하나씩 꺼내서 출력.

if (recipe.potionName == name) //이름으로 검색

bool found = false; // found변수 찾으면 ture

if (recipe.ingredient1 == ingredient || recipe.ingredient2 == ingredient)// 재료로 검색

재료1이 같거나 재료2가 같으면 검색 성공

Step8

메인 메뉴 중심으로 전체 기능을 연결

while (true)
{
    cout << "1. 던전 입장" << endl;
    cout << "2. 인벤토리 확인" << endl;
    cout << "3. 포션 제작소" << endl;
    cout << "0. 게임 종료" << endl;
    cin >> menuChoice;
    if (menuChoice == 1)
    {
        // 던전 입장 + 전투
    }
    else if (menuChoice == 2)
    {
        // 인벤토리 확인
    }
    else if (menuChoice == 3)
    {
        // 포션 제작소
    }
    else if (menuChoice == 0)
    {
        break;
    }
}

던전입장

if (dungeonChoice == 1)
{
monster = Monster("슬라임", 30, 20, 10, "슬라임의 끈적한 젤리", 30);
}
else if (dungeonChoice == 2)
{
monster = Monster("고블린", 50, 25, 15, "고블린의 이빨", 50);
}

던전 번호에 따라 다른 몬스터 객체를 만든다.

==================================================================

외울코드

==================================================================

입력반복

while (true)
{
    cin >> value;

    if (조건)
    {
        break;
    }
}

메뉴 반복

while (true)
{
    cin >> choice;

    if (choice == 0)
    {
        break;
    }
}

switch 메뉴

switch (choice)
{
case 1:
    break;

case 0:
    break;

default:
    break;
}

포인트 객체접근

player->getHP();

일반 객체접근

monster.getHP();

vector추가

inventory.push_back(item);

vector전체 출력

for (const Item& item : inventory)
{
item.PrintInfo();
}

전투 반복

while (player->getHP() > 0 && monster.getHP() > 0)
{
}

데미지 계산

int damage = attackPower - defence;

if (damage <= 0)
{
damage = 1;
}

개념 코드 의미

문자열	string name;	이름 저장
배열	int stat[SIZE];	능력치 저장
무한 반복	while(true)	계속 반복
반복 탈출	break;	반복문 종료
조건문	if	조건 검사
그리고	&&	둘 다 참
또는	`
클래스	class Player	객체 설계도
구조체	struct Item	단순 데이터 묶음
상속	class Warrior : public Player	Player 기능 물려받기
순수 가상 함수	virtual void attack() = 0;	자식에게 구현 강제
오버라이딩	void attack() override	자식이 함수 재정의
포인터	Player* player	객체 주소 저장
동적 생성	new Magician(...)	객체 생성
메모리 해제	delete player;	객체 삭제
포인터 접근	player->getHP()	포인터 멤버 접근
객체 접근	monster.getHP()	일반 객체 멤버 접근
vector	vector<Item> inventory;	동적 배열
추가	push_back()	vector에 저장
크기	size()	개수 확인
비었는지	empty()	비어 있는지 확인
전체 순회	for (const Item& item : inventory)	모든 요소 반복

햇갈리는 포인트

getter/setter

4/29(코드카타,과제2 step8)

백구 — Wed, 29 Apr 2026 15:09:02 +0900

코드카타

#include <string>
#include <vector>

using namespace std;

string solution(vector<string> seoul) {
    for (int i = 0; i < seoul.size(); i++) {
        if (seoul[i] == "Kim") {
            return "김서방은 " + to_string(i) + "에 있다";
        }
    }
    return "";
}

문자열 배열에서 하나씩 비교하는걸 배웠다.

step5

getter / setter를 사용

getHP()
getPower()
getDefence()
setHP()

player->getHP()
player->getPower()
player->getDefence()
player->setHP(...)

전투루프 while (player->getHP() > 0 && monster.getHP() > 0)

getHP()와 setHP()를 헷갈립니다.

getHP() // 값 읽기
setHP() // 값 바꾸기

ex)

int hp = player->getHP(); // 읽기
player->setHP(50); // 변경

step6

struct Item으로 아이템 구조체만듦.

#include <vector>

백터는 아이템이 몇 개 들어올지 모를 때 쓰기 좋은 동적배열입니다.

vector<Item> inventory;

==> 아이템들을 여러개 저장할 수 잇는 공간

int index = 1;
for (const Item& item : inventory)
{
    cout << index << ". ";
    item.PrintInfo();
    index++;
}

여기서 인덱스는 진짜 인덱스가 아니고 화면에 보여줄 1. 2.이런 번호입니다.

알면 좋은것들

1. Item 구조체 정의
2. vector<Item> inventory 선언
3. 전투 승리
4. droppedItem 생성
5. inventory.push_back(droppedItem)
6. 메인 메뉴 출력
7. 인벤토리 메뉴에서 저장된 아이템 출력

step7

스텝7은 스탭6의 확장버전같습니다.

if (recipe.potionName == name) 이름검색

if (recipe.ingredient1 == ingredient || recipe.ingredient2 == ingredient) 재료검색

step8

은 여태까지 만든걸 합친느낌입니다.

4/28 (코드카타,c++,과제1,과제2/step4)

백구 — Tue, 28 Apr 2026 20:33:50 +0900

첫시간은 코드카타이고 오늘 푼 문제이다

주어진 수가 6이라면 6 → 3 → 10 → 5 → 16 → 8 → 4 → 2 → 1 이 되어 총 8번 만에 1이 됩니다. 위 작업을 몇 번이나 반복해야 하는지 반환하는 함수, solution을 완성해 주세요. 단, 주어진 수가 1인 경우에는 0을, 작업을 500번 반복할 때까지 1이 되지 않는다면 –1을 반환해 주세요.

using namespace std; 

using namespace std; 

int solution(int num) { 
    long long n = num; 

    for (int count = 0; count <= 500; count++) { 
        if (n == 1) { 
            return count; 
        } 

        if (n % 2 == 0) { 
            n /= 2; 
        } 
        else { 
            n = n * 3 + 1; 
        } 
    } 

    return -1; 
}

오늘은 c++에서 액터생성후 액터가 랜덤하게 이동하고 회전하도록 구연했습니다.

또한 이동 횟수,현재 좌표,이벤트 발생횟수,총 이동 거리 등을 화면에 출력하도록 하였고 git에 업로드까지 하였습니다.

기억해야할점

cpp에 함수를 만들기전에 h에 함수선언을 해야한다

BeginPlay()는 게임이 시작될때 한 번 실행되는 함수입니다.

시작위치를 고정할때는 SetActorLocation(FVector(0.0f, 0.0f, 50.0f));을 썼습니다.

언리얼에서 위치는 FVector로 표현합니다

위치를 가져올때는 GetActorLocation 변경할때는 SetActorLocation을 사용합니다.

이번에는 액터가 바라보는 방향으로 이동하게 만들기 위해서 GetActorFowardVector()를 사용했습니다.

FVector ForwardDirection = GetActorForwardVector();

마찬가지로 GetActorLocation와 비슷하게 GetActorRotation는 회전시킬때 사용합니다.

언리얼 c++에서 랜덤값을 만들때 FMath::RandRange()를 사용하였습니다.

float RandomDistance = FMath::RandRange(50.0f, 200.0f);

이코드는 50~200사이의 값을 뽑아 오는거고 50%로 할때는 0과1을 사용하면 됩니다.

이전 위치와 현재 위치 사이의 거리는 FVector::Dist()로 계산할수 있습니다.

이 과제에서 이동할 때마다 이동 거리를 누적해서 총 이동거리를 계산했고

토탈무브디스턴스에 추가 해주었습니다.

화면에 로그출력하기

GEngine->AddOnScreenDebugMessage(-1, 3.0f, FColor::Green, Message);

-1은 새 메세지로 출력

3.0f는 3초동안 표시

한글로 출력했다가 다 깨져서 영어로 출력하는게 안전하다고 경험했습니다 ㅜㅜ

이번에 기억할것

1. .h 파일에는 함수와 변수를 선언한다.
2. .cpp 파일에는 함수의 실제 동작을 구현한다.
3. AMyActor::Move()에서 ::는 클래스 소속을 의미한다.
4. BeginPlay()는 게임 시작 시 한 번 실행된다.
5. 위치는 FVector, 회전은 FRotator를 사용한다.
6. GetActorLocation()으로 현재 위치를 가져온다.
7. SetActorLocation()으로 위치를 바꾼다.
8. GetActorRotation()으로 현재 회전을 가져온다.
9. SetActorRotation()으로 회전을 바꾼다.
10. GetActorForwardVector()를 사용하면 Actor가 바라보는 방향으로 이동할 수 있다.
11. FMath::RandRange()로 랜덤 값을 만들 수 있다.
12. FVector::Dist()로 두 위치 사이의 거리를 계산할 수 있다.
13. 언리얼 프로젝트를 GitHub에 올릴 때 Binaries, Intermediate, Saved 같은 자동 생성 폴더는 제외해야 한다.

그후 2번과제를 시작했습니다.

2번과제 step1

기억해야할것

main이 시작점이다

cout 화면에 출력
cin 키보드로 입력받기
endl 줄바꿈

ex)

cin >> stat[0] >> stat[1];

cin >> stat[2] >> stat[3];

#include <string> 문자열을 사용하기 위해 필요

using namespace std;

==> std:: 생략가능

step2

기억해야할것

핵심개념

while (true)

if (조건)

(기존코드)

cout << "HP와 MP를 입력해주세요: ";
cin >> stat[0] >> stat[1];

(바뀐코드)

while (true)
{
    cout << "HP와 MP를 입력해주세요: ";
    cin >> stat[0] >> stat[1];

    if (stat[0] >= 50 && stat[1] >= 50)
    {
        break;
    }

    cout << "HP나 MP의 값이 너무 작습니다. 다시 입력해주세요." << endl;
}

step3

기억해야할것

while (!isGameStart)
{
    메뉴 출력
    번호 입력

    switch (choice)
    {
    case 1:
        HP 증가
        break;

    case 2:
        MP 증가
        break;

    case 0:
        isGameStart = true;
        break;
    }
}

step4

기억해야할것

protected 자식클래스에서 ㅈ버근할 수 있지만,클래스 밖에서는 직접 접근할 수 없음.

순수 가상 함수

virtual void attack() = 0;

ex)

Player는 attack()이라는 함수가 있어야 한다.
그런데 Player 자체는 공격 방식을 정하지 않는다.
자식 클래스가 반드시 직접 정해야 한다

상속

class Magician : public Player

자식 클래스 생성자

Magician(string name, int hp, int mp, int power, int defence)
    : Player(name, hp, mp, power, defence)
{
    job = "마법사";
    mp += 30;
}

오버라이딩

부모클래스의 함수를 자식 클래스에서 다시 정의하는것

다형성

Player* player = nullptr; 이코드 하나로

player = new Warrior(...);/player = new Magician(...);모두 다룰수 있다.

어려운코드

virtual void attack() = 0;

순수가상함수인데 일반함수는 몸통이 있는것과 달리

몸통이없다

==>뜻은

Player에는 attack이라는 함수가 있어야 한다.
하지만 Player가 직접 공격 방식을 정하지는 않는다.
자식 클래스가 반드시 attack을 만들어야 한다.

라고 생각하면 된다.

개념의미

순수 가상 함수	부모가 자식에게 “이 함수 반드시 만들어라”라고 강제하는 함수
추상 클래스	순수 가상 함수를 가진 클래스. 직접 객체 생성 불가
오버라이딩	부모의 함수를 자식이 자기 방식으로 다시 구현하는 것
다형성	같은 player->attack() 코드가 실제 객체에 따라 다르게 동작하는 것
new	객체를 동적으로 생성
delete	new로 만든 객체를 삭제

4/27(코드카타,발표)

백구 — Mon, 27 Apr 2026 20:32:08 +0900

코드카타 22번 문제를 풀었습니다.

날이 갈수록 어려워 집니다..

두 정수 a, b가 주어졌을 때 a와 b 사이에 속한 모든 정수의 합을 리턴하는 함수, solution을 완성하세요.
예를 들어 a = 3, b = 5인 경우, 3 + 4 + 5 = 12이므로 12를 리턴합니다.

이게 문제이고 밑은 답입니다.

long long solution(int a, int b) {
    long long answer = 0;

    if (a > b) {
        int temp = a;
        a = b;
        b = temp;
    }

    for (int i = a; i <= b; i++) {
        answer += i;
    }

    return answer;
}

a와b의 대소 관계는 정해지지 않았기 때문에 a와b의 대소를 맞춥니다.

그후 for문을 이용해 그 사이의 것을 다 더합니다.

문제가 어려워 파악하는데 많은 시간을 썼습니다.

그후 미니발표시간에

기본적인 블루프린트 노드에 대해 발표하였습니다.

그후 깃에대해 배웠습니다.

4/24(코드카타,C++실시간강의,FPS강의)

백구 — Fri, 24 Apr 2026 15:14:21 +0900

코드카타 21번문제를 풀었습니다.

#include <string>
#include <vector>

using namespace std;

bool solution(int x) {
    bool answer = true;
    int sum = 0;
    for (int i = 0; i < x; i++) {
        int temp = x;
        for (; temp > 0; temp /= 10) {
            sum += temp % 10;
        }
        break;
    }
    if (x % sum == 0) {
        answer = true;
    }
    else {
        answer = false;
    }
    return answer;
}

바깥의 for문은 beak때문에 사실상 한번만 실행된다고 볼수있다.

아래 temp는 왜 x를 안쓰냐 -> 마지막에 검수할때 x를 썼다면 판별을 할수 없기 때문이다.

반복이 끝날 때 마다 temp를 10으로 나눔

-> for문 끝에서 % 10을 해서 나머지를 sum에 더하기

의 반복이다.

그후 참거짓을 판별하는 코드이다.

그리고 블루프린트 발표자료를 만들었습니다.

c++실시간강의

배열(Array)

자료구조 중 가장 기초가 되는 자료구조.

사용할 메모리 크기를 고정해서 선언하는 것이 특징입니다.

선언된 후에는 절대 그 크기를 변경 불가합니다. 그래서 정적인 자료구조라고도 합니다.

선언된 메모리는 연속적으로 할당됩니다.

#include <stdio.h>

int main(void)
{
int i;
int Array[4] = { 1, 2, 3, 4 };

for (i = 0; i < 4; ++i)
{
printf("%d ", Array[i]);
}

return 0;
}

2차원 배열

#include <stdio.h>

int main(void)
{
int i, j;
int Array2D[4][3] = { { 1,  2,  3, },
  { 4,  5,  6, },
  { 7,  8,  9, },
  {10, 11, 12, } };

for (i = 0; i < 4; ++i)
{
for (j = 0; j < 3; ++j)
{
printf("%2d ", Array2D[i][j]);
}
printf("\n");
}

return 0;
}
함수(Function)

프로그래밍 언어에서 함수란, 코드 뭉치.

반복되는 코드 뭉치가 있다면 해당 코드 뭉치를 함수로 만들어서 재사용성을 높힐 수 있습니다.

입력 혹은 출력이 있는 경우 대부분 다 함수라고 봐도됩니다.

반환자료형 함수명(매개변수자료형 매개변수명) // 함수 선언(Declaration)이자, 정의(Definition)
{

return 반환값;
}

int main(void)
{
int num = 10; // 자료형 변수명 = 값;

함수명(인자값); // 함수 호출(Call)

return 0;
}

스코프

변수나 함수 이름을 사용할 수 있는 범위를 뜻합니다.

스코프의 종류

1. 블럭 스코프(Block Scope)

2. 파일 스코프(File Scope)

블럭스코프

중괄호 내부에 선언된 변수는 해당 중괄호 내부에서만 사용할 수 있습니다.

조건문, 반복문 같은 문(statement)에 사용되는 중괄호 범위도 블럭 스코프라고 합니다.

블럭 스코프 안에 또 다른 블럭 스코프가 들어갈 수도 있습니다.

바깥쪽 블럭 스코프에서 안쪽 블럭 스코프에 선언된 지역 변수에 접근 불가능합니다.

반대로 바깥쪽 블럭 스코프에 선언된 지역 변수를 안쪽 블럭 스코프에서는 접근 가능합니다.

전방 선언

함수의 원형(머리부분)만 따서 파일 스코프 상단에 두고 함수의 정의는 파일 스코프의 하단에 위치 시키는 방법입니다.

변수의 종류

변수에는 지역 변수/전역 변수가 있습니다. 여기에 static이나 const, extern 같은 키워드가 붙어서 조금씩 뉘앙스가 달라집니다.

지역 변수

함수를 하나의 마을이라고 생각해봅시다.

main() 마을에서는 Add() 마을에서 선언된 지역 변수 A를 접근할 수 없습니다.

그리고 Add() 함수가 종료되면, 지역 변수 A도 사라진다고 이해합시다.

정적 지역 변수

지역 변수 앞에 static 키워드가 붙으면 데이터 섹션에 저장됩니다.

즉, 함수 종료시 접근 불가한 스택메모리에 저장되는게 아닙니다.

함수가 종료되어도 값이 유지가 됩니다 이런 변수를 정적 지역 변수라고 부릅니다.

전역 변수

파일 스코프에 선언된 변수. 데이터 섹션에 저장됩니다.

const 변수

const 키워드가 붙은 변수. 초기화 이후에 값을 변경할 수 없습니다. 초기화가 강제됩니다.

포인터

자료형 변수명 = 값;

자료형* 변수명 = 메모리주소값; // 자료형쪽에 Asterisk를 붙힙시다.
// 변수명쪽에 Asterisk를 붙히면 뒤에서 배울 역참조 연산자와 심히 헷갈립니다.

포인터를 선언할 때 자료형은 왜 필요할까요?

해당 메모리 주소로 가서 얼마만큼의 크기로 읽어야 내 데이터인지 모르기 때문입니다.

자료형이 있어야 크기를 알 수 있습니다.

더 나아가서, 자료형 크기만큼 가면 다음 데이터를 얻을 수도 있습니다.

주소 연산자와 역참조 연산자

역참조 연산자

피연산자로 포인터를 받아서, 해당 메모리 주소에 저장된 값을 읽거나 값을 수정할 때 사용하는 연산자.

#include <stdio.h>

int main(void)
{
int X = 10;
int* PtrToX = &X;

printf("%d\n", *PtrToX);

*PtrToX = 100;

printf("%d\n", *PtrToX);

return 0;
}

포인터의 단점

큰 데이터들의 시작 메모리 주소만으로 가볍게 공유할 수 있다는 점은 좋습니다.

다만, 공유 받은 사람이 착한 사람인지는 모릅니다.

해당 주소로 가서 들어있는 값을 마음대로 수정 할수도 있습니다.

아주 강력한 기능임과 동시에 그만큼 잘못쓰면 큰일 날 수도 있습니다.

NULL 포인터

#define NULL ((void*)0)

아무것도 가르키지 않는 포인터.

자료형이 정해지지 않은 포인터

자료형* 변수명 = 메모리주소값;

NULL 포인터는 메모리주소값이 아직 정해지지 않았을 때 사용 했습니다.

자료형을 지금 바로 정할 수 없을 때도 있습니다.

void 포인터

범용 포인터라고도 부릅니다.

void* 변수명 = 메모리 주소 값;

코드 섹션과 데이터 섹션

코드 섹션: 우리가 작성한 소스코드들이 빌드된 결과물들이 저장되는 곳입니다.

데이터 섹션: 전역 변수와 정적 변수등이 저장되는 곳입니다.

스택 메모리의 단점

스택 메모리에 저장되는 지역 변수(배열 등)의 크기는 컴파일 타임에 고정됩니다.

런타임에 더 필요해진다 해도 크기를 늘릴 수 없습니다.

함수가 종료되면 해당 스택 프레임에 더이상 접근 불가능합니다.

즉, 지역변수의 수명은 함수의 수명과 함께합니다.

더 오래 보존하려면 전역변수 혹은 정적변수로 선언해야 합니다.

근데 이 변수들은 너무 또 극단적입니다. 프로그램의 수명과 함께합니다.

힙 메모리

스택 메모리에 비교해 할당/해제 속도가 느립니다.

스택 메모리는 자료구조 스택의 특성상 할당 및 해제에 O(1) 시간이 걸립니다.

힙 메모리는 할당 받아오려면 사용중이지 않은 메모리이면서 크기가 맞는지 체크 후 제공됩니다.

또한 메모리 공간에 구멍(메모리 단편화)이 생길 수도 있어서 효율적인 메모리 관리가 어렵기도 합니다.

동적 할당의 세 가지 단계

1. 메모리 할당(대여)

힙 메모리 관리자에게 필요한 바이트만큼의 메모리를 달라고 요청합니다.

힙 메모리 관리자는 해당 크기의 연속된 메모리를 찾아서 반환합니다.

반환된 값은 시작 메모리 주소입니다.

2. 메모리 사용 할당된 힙 메모리 시작 주소를 가지고 원하는 작업 수행합니다.

이때 할당된 메모리 속 데이터는 쓰레기값입니다.

3. 메모리 해제(반납) 힙 메모리 관리자에게 해당 메모리 주소를 돌려주면서 다 썼다고 알립니다.

힙 메모리 관리자는 해당 메모리를 점유되지 않은 메모리 상태로 바꿉니다.

메모리 주소를 돌려주지 않으면 메모리 누수(Memory leak) 발생합니다.

메모리 누수란, 해당 메모리가 점유 상태를 벗어나지 못해 사용가능한 메모리가 줄어드는 현상입니다.

malloc() 함수와 free() 함수

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
size_t i;
int* Nums = (int*)malloc(10 * sizeof(int));
if (NULL == Nums)
{
return 0;
}

// Do something....

free(Nums);
Nums = NULL;

if (NULL != Nums)
{
// TODO.
}

return 0;
}

구조체

필요한 여러 자료형의 변수들을 한데 묶어서 하나의 자료형처럼 만들 수 있습니다.

함수의 인자로 구조체 변수 전달

#include <stdio.h>

struct Date
{
int Year;
int Month;
int Day;
};

void PrintBirthday(struct Date InBirthday);

int main(void)
{
struct Date Birthday;
Birthday.Year = 2024;
Birthday.Month = 1;
Birthday.Day = 13;
// 구조체 변수 Birthday는 어느 메모리에 저장 될까요?.
// 당연하게도 스택 메모리입니다. 다른 기본 자료형과 마찬가지입니다.
// 초기화 하지 않으면 0이 아닌 쓰레기 값이 저장되어 있습니다.

PrintBirthday(Birthday);

return 0;
}

void PrintBirthday(struct Date InBirthday)
{
printf("%d/%d/%d\n", InBirthday.Year, InBirthday.Month, InBirthday.Day);
}

구조체와 객체지향 프로그래밍

나만의 자료형처럼 만든다는 것은 OOP에서 하나의 물체를 정의하는 것과 같습니다.

나만의 자료형으로 물체(객체)를 정의하고, 동적할당을 이용해서 물체를 생성 후 원하는 때에 해당 물체를 제거합니다.

이는 객체지향 프로그래밍과 유사합니다.

멤버 함수

#include <stdio.h>
#include <stdlib.h>

struct Human
{
float Height;

float Weight;

size_t Age;

void SayHello(void)
{
printf("Hello!\n");

return;
}

void SayMyInfo(void)
{
printf("My Height is %.1f.\n", Height);
printf("My Weight is %.1f.\n", Weight);
printf("My age is %zu.\n\n", Age);

return;
}

};
typedef struct Human Human_t;

int main(void)
{
Human_t* Park = (Human_t*)malloc(1 * sizeof(Human_t));
Park->Height = 173.f;
Park->Weight = 70.f;
Park->Age = 19;

Park->SayHello();
Park->SayMyInfo();

free(Park);
Park = NULL;

return 0;
}

열거형

정수에 별명을 붙여서 소스코드를 이해하기 쉽게 해줍니다.

enum

#include <stdio.h>

enum EMonth
{
MONTH_JAN = 1,
MONTH_FEB = 2,
MONTH_MAR = 3,
MONTH_APR = 4
};

enum EASCII
{
ASCII_A = 65,
ASCII_B,
ASCII_C,
ASCII_D
};

int main(void)
{
printf("This month's(%d) lucky character is %c.", 3, 66);
// 갑자기 숫자 3과 66이 튀어나오면 이해가 안될 수 있습니다.

int March = 3, B = 66;
printf("This month's(%d) lucky character is %c.", March, B);
// 물론 위와 같이 하면 가독성이 좋아지긴 하나, 변수가 메모리 공간을 잡아먹음.

printf("This month's(%d) lucky character is %c.", MONTH_MAR, ASCII_B);

return 0;
}

이후

블루프린트 fps강의만들었습니다.

https://youtu.be/FBxpE3OSPPI