journey46110 님의 블로그

개념 정리 - C++ (함수 오버로딩과 템플릿)

journey46110 — Thu, 23 Jul 2026 21:21:20 +0900

I. 함수 오버로딩

1) 함수 오버로딩의 정의

같은 이름의 함수를 여러 개 만들되, 매개변수가 달라야 하는 것

void Print(int n)
{
    cout << n;
}

void Print(double d)
{
    cout << d;
}

Print(10);      // int 버전
Print(3.14);    // double 버전

2) Name Mangling

C++에서 함수 오버로딩이 가능한 이유

① C에서 함수를 기억하는 방식

Print(int a); //Print로 기억함

② C++에서 함수를 기억하는 방식

이를 Name Mangling이라고 함

Print(int a);
Print(double b);
Print(char c);

//컴파일러 내부에서 스스로 아래처럼 이름을 바꿔서 각각 다른 함수로 저장함
//Print_int, Print_double, Print_char

3) 오버로딩이 가능한 경우

① 매개변수 타입이 다를 때

void Print(int a);
void Print(double a);

② 매개변수 개수가 다를 때

void Print(int a);
void Print(int a, int b);

4) 오버로딩이 불가능한 경우

컴파일러가 어느 함수를 호출하는지 애매모호할 때 컴파일 에러가 일어남

① 호출 우선 순위가 같을 때

void Print(int a);
void Print(double a);

Print('A'); //char는 int와 double로 각각 손실이 없는 변환이 가능함

② 디폴트 매개변수가 있을 때

void Print(int a, int b = 10);
void Print(int a);

Print(10); //int b = 10의 디폴트 매개변수로 인해서 두 함수 다 호출이 가능함

③ 매개변수의 타입이 포인터와 배열의 차이 뿐일 때

void Print(int* arr);
void Print(int arr[]);

Print(arr); //포인터와 배열은 같은 타입으로 취급됨 int* arr == int arr[]

④ 함수의 반환형만 다를 때

int Add(int a, int b);
double Add(int a, int b);

Add(1, 2); //어느 함수를 호출해야할 지 애매모호함

5) 오버로딩 호출 우선 순위

우선 순위: 정확히 일치 -> 승격 변환 -> 표준 변환 -> 사용자 정의 변환

① 정확히 매개변수 타입이 일치

void Print(int a);
void Print(double a);

Print(10); //정확히 타입이 일치하는 int가 호출됨

② 타입 승격 변환

정보 손실이 없는 변환

char → int
short → int
float → double
bool → int

void Print(int a);
void Print(char a);

short s = 10;
print(s); //int로 타입 승격 변환이 가능함

③ 표준 타입 변환

정보 손실이 일어날 수 있는 변환

int → double
double → int
double → float

void Print(int a);
void Print(string a);

double num = 10.01;
Print(num); //int로 표준 타입 변환이 일어남

④ 사용자 정의 변환

클래스 생성자나 변환 연산자를 이용한 변환

class Number {
public:
    operator int() const { return 67; }
};

void Print(int a);
void Print(double a);

Number num;
print(num);  //사용자 정의 변환을 통해 Number→int로 변환됨

II. 템플릿

1) 템플릿의 필요성

동작은 같지만 반환형과 매개변수의 자료형만 다른 함수들

int Add(int a, int b);
double Add(double a, double b);
float Add(float a, float b);

템플릿은 자료형만 바뀌는 함수를 하나로 만들자는 취지에서 사용됨

장점

① 코드 중복 감소

② 유지보수 쉬움

③ 새로운 자료형도 바로 사용 가능

④ STL(vector, list, map 등)의 기반 기술

2) 사용법

함수 위에 이 문법을 적어줌

template<typename T>
혹은
template<class T>

예시

template<typename T>
T Add(T a, T b)
{
    return a + b;
}

Add(10,20);      //30 출력
Add(1.5,2.3);    //3.8 출력
Add('A','B');    //AB출력

컴파일러가 자료형과 반환형이 들어맞는 함수를 대신 만들어줌

3) 템플릿 클래스

함수뿐 아니라 클래스도 일반화할 수 있음

template<typename T>
class Array
{
private:
    T data[100];
    int size;

public:
    Array()
    {
        size = 0;
    }
    void Add(T value)
    {
        data[size++] = value;
    }
};

Array<int> numbers;
Array<string> names;
Array<double> scores;

같은 클래스인데 자료형만 달라짐

4) 함수 오버로딩 vs 템플릿

함수 오버로딩	템플릿
자료형마다 직접 함수 작성	하나의 함수만 작성
코드 중복 발생	코드 중복 감소
구현이 단순	범용적이고 재사용성 높음
자료형이 많아질수록 함수도 많아짐	자료형이 늘어나도 코드 그대로

개념 정리 - C++ (메모리 관리)

journey46110 — Wed, 22 Jul 2026 19:27:32 +0900

I. C++의 메모리 관리

1) 메모리의 종류

프로그램이 사용하는 메모리는 크게 스택(Stack) 과 힙(Heap) 으로 나누어짐

구분	스택 (Stack)	힙 (Heap)
관리	컴파일러가 자동으로 관리해줌	프로그래머가 직접 관리해야 함
속도	빠름	느림
크기	작음	큼
생명주기	블록({}) 종료 시 자동 해제	delete 할 때까지 유지

2) 스택 (Stack)

① 함수가 실행될 때 메모리의 모습

void Func()
{
    int a = 10;
}


Stack
┌────────┐
│ a = 10 │
└────────┘

② 함수가 종료될 때(블록{}을 벗어날 때) 메모리의 모습

Stack
(비어 있음)

함수가 끝나는 순간 자동으로 메모리에서 사라짐

③ 특징

장점 - 빠름, 자동으로 관리됨, 메모리 누수가 없음

단점 - 크기가 작음, 함수가 끝나면 사라짐

3) 힙 (Heap)

직접 메모리를 빌리는 공간

Player* player = new Warrior(...);

Stack
player
 │
 ▼
Heap
Warrior 객체

함수가 종료되어도 객체가 살아있음

delete player;

자동으로 없어지지 않고, 직접 delete를 해줘야 함

힙을 사용하는 이유

① 크기를 실행 중에 결정할 수 있음

cin >> size;
int* arr = new int[size];

사용자가 입력한 크기만큼 배열을 만들 수 있음

표준 C++에서는 int arr[size]; 불가능

② 함수가 끝나도 객체를 살아있게 할 수 있음

Player* CreatePlayer()
{
    return new Warrior(...);
}

함수가 끝나도 Warrior 객체가 살아있음

③ 다형성

Player* player1 = new Warrior();
Player* player2 = new Magician();
Player* player3 = new Archer();

가상 함수를 이용해 override를 할 때 힙을 자주 이용함

4) 메모리 누수 (Memory Leak)

Player* player = new Warrior(...);

//delete player;

delete를 안 했기에 메모리에 객체가 계속 남아 있음

객체가 계속 쌓이면 메모리가 부족해짐

5) Dangling Pointer

메모리를 지웠는데, 포인터가 그대로 남아 있는 경우

Player* player = new Warrior();
delete player;

player->attack();

없어진 메모리를 가리키는 경우

delete player;
player = nullptr;

보통 이렇게 같이 씀

6) Double Delete

이미 지운 메모리를 또 지우는 경우

delete player;
delete player;

이 경우도 위험함

7) 스마트 포인터

힙을 쓸 때 직접 new와 delete를 쓰면 실수하기 쉬움

스마트 포인터는 자동으로 delete를 해줌

① unique_ptr

메모리를 소유하는 소유자가 딱 한 개

객체 하나를 관리할 때 자주 사용함

unique_ptr
      │
      ▼
    Warrior

unique_ptr<Player> p1 = make_unique<Warrior>();
unique_ptr<Player> p2 = p1; //복사 안 됨, 컴파일 에러 발생

move를 사용해서 소유권 이전만 가능, 이때 소유권이 없어진 쪽은 nullptr이 됨

unique_ptr<Player> p2 = move(p1);

p1
nullptr

p2
 │
 ▼
Warrior

② shared_ptr

여러 포인터가 한 메모리를 같이 소유함

P1
 \
  \
   Warrior
  /
 /
P2

shared_ptr<Player> p1 = make_shared<Warrior>();
cout << "p1의 레퍼런스 카운트: " << p1.use_count() << endl; //출력 1

shared_ptr<Player> p2 = p1;
cout << "p2 생성 후 레퍼런스 카운트: " << p1.use_count() << endl; //출력 2

p2.reset();
cout << "p2 해제 후 레퍼런스 카운트: " << p1.use_count() << endl; //출력 1

return 0;
}

내부적으로 Reference Count를 가짐

reset을 이용해 소유권을 해제할 수 있음

③ weak_ptr

서로를 shared_ptr로 참조하는 경우 레퍼런스 카운트가 0이 되지 않음, 이를 순환참조라고 함

A
↓
B
↑
A

이때, 한쪽을 weak_ptr으로 바꾸면 순환참조가 풀림

weak_ptr은 레퍼런스 카운트에 영향을 미치지 않아서, lock으로 유효성을 검사해야 함

#include <iostream>
#include <memory>
using namespace std;

class Monster {
public:
    void roar() {
        cout << "슬라임이 울부짖습니다!" << endl;
    }
};

class Stage {
public:
    weak_ptr<Monster> monster;

    void checkMonster() {
        if (auto currentMonster = monster.lock()) {
            currentMonster->roar();
        }
        else {
            cout << "몬스터가 이미 사라졌습니다." << endl;
        }
    }
};

int main() {
    shared_ptr<Stage> stage = make_shared<Stage>();

    {
        shared_ptr<Monster> slime = make_shared<Monster>();

        stage->monster = slime;

        stage->checkMonster();   // 몬스터 존재
    }

    // slime 소멸

    stage->checkMonster();       // 몬스터 없음
}

해설

shared_ptr<Monster> slime = make_shared<Monster>();
slime(shared_ptr)
      │
      ▼
   Monster
   
stage->monster = slime;
slime(shared_ptr)
      │
      ▼
   Monster
      ▲
      │
monster(weak_ptr)

auto currentMonster = monster.lock();
slime(shared_ptr)
      │
      ▼
   Monster
      ▲
      │
currentMonster(shared_ptr)

중괄호를 벗어나서 slime이 해제될 때, monster(weak_ptr)도 같이 해제됨

8) 얕은 복사와 깊은 복사

① 얕은 복사

포인터를 복사할 때, 값이 아니라 주소만 복사하는 것

int* a = new int(10);
int* b = a;

delete a;
cout << *b; // b -> dangling pointer

둘 다 같은 메모리를 가리킴
하나를 삭제하면, 나머지 하나는 dangling pointer가 됨

② 깊은 복사

포인터가 가리키는 메모리의 값을 새로운 메모리에 복제하는 것

int* a = new int(10);
int* b = new int(*a);

delete a;
cout << *b; //아무 문제 없음

II. 언리얼 엔진의 메모리 관리

1) 가비지 컬렉션 (Garbage Collection)

언리얼 엔진 내부에서는 new와 delete를 직접 쓰지 않음
대신에 Garbage Collection을 주로 사용함

작동 방식 - Mark & Sweep 알고리즘

주기적으로 실행됨

더 이상 프로그램에서 사용하지 않는다고 판단되는 객체를 메모리에서 제거함

① 루트셋 (Root Set)

루트셋에 포함된 객체를 식별

플레이 중에 항상 존재해야되는 객체를 포함함

② Mark 단계

루트셋의 객체에서 직간접적으로 참조할 수 있는 객체에 표시를 함

③ Sweep 단계

Mark 단계에서 표시되지 않은 객체를 메모리에서 제거함

2) 리플렉션 시스템

언리얼 엔진은 클래스 내부에 무엇이 들어있는 지 런타임 동안 모름

리플렉션 매크로를 사용하면 컴파일러의 수행 전에 사용자가 정의한 타입을 언리얼 엔진이 알게 해줌

자주 사용하는 매크로

매크로	역할
UCLASS()	클래스 등록
USTRUCT()	구조체 등록
UPROPERTY()	멤버 변수 등록
UFUNCTION()	함수 등록
GENERATED_BODY()	리플렉션 코드 삽입

예시

UCLASS(Blueprintable, BlueprintType)
class YOURPROJECT_API UPlayerData : public UObject
{
    GENERATED_BODY()

public:
    UPlayerData();

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Player")
    int32 Level = 1;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Player")
    float HP = 100.f;

    UFUNCTION(BlueprintCallable, Category = "Player")
    void LevelUp();
};

개념 정리 - C++ (상속, 다형성)

journey46110 — Fri, 17 Jul 2026 19:17:52 +0900

I. 상속 (Inheritance)

1) 상속의 필요성

비슷한 클래스가 여러 개 있을 때 공통 코드를 재사용하기 위해 사용함

예시 - 자동차, 자전거, 트럭은 색깔과 속도라는 공통 부분이 있음

class Bicycle
{
    string color;
    int speed;
};

class Truck
{
    string color;
    int speed;
};

각각 구현하면 중복이 생김

        Vehicle
      /         \
 Bicycle       Truck

그래서 공통 부분을 기본 클래스(부모 클래스)로 따로 뺌

2) 상속 문법

class Vehicle
{
};

class Bicycle : public Vehicle
{
};

Bicycle은 Vehicle을 상속받음

Bicycle의 기능과 Vehicle의 기능을 모두 가짐

3) Is-A 관계

상속을 사용할 수 있는 가장 쉬운 기준

예시

Bicycle은 Vehicle이다. (O)

Truck은 Vehicle이다. (O)

-> 이런 경우 상속에 해당함

잘못된 예시

Engine은 Vehicle이다. (X)
Vehicle은 Engine을 가진다. (O)
-> 이런 경우 포함(Composition)에 해당함

4) 부모 생성자 호출

자식 클래스(파생 클래스) 생성 시 부모 클래스가 먼저 생성되어야 함

class Vehicle
{
public:
    Vehicle(string color, int speed)
    {
    }
};

class Bicycle : public Vehicle
{
public:
    Bicycle(string color, int speed)
        : Vehicle(color, speed)
    {
    }
};

순서: Vehicle 생성 -> Bicycle 생성

5) 멤버 초기화 리스트

생성자보다 먼저 실행됨

Person(string n)
    : name(n)
{
}

기존에 쓰던 name=n; 보다 효율적

6) 상속 활용 예시

#include <iostream>
#include <string>

using namespace std;

// 부모 클래스
class Vehicle {
protected:
    string color;
    int speed;

public:
    Vehicle(string c, int s) : color(c), speed(s) {}

    void move() {
        cout << color << " vehicle is moving at "
             << speed << " km/h." << endl;
    }

    void stop() {
        cout << "The vehicle has stopped." << endl;
    }

    string getColor() {
        return color;
    }
};

// 자전거
class Bicycle : public Vehicle {
private:
    bool hasBasket;

public:
    Bicycle(string c, int s, bool basket)
        : Vehicle(c, s), hasBasket(basket) {}

    void ringBell() {
        cout << "Ring Ring!" << endl;
    }

    void showBasket() {
        if (hasBasket)
            cout << "This bicycle has a basket." << endl;
        else
            cout << "This bicycle doesn't have a basket." << endl;
    }
};

// 자동차
class Car : public Vehicle {
private:
    int doorCount;

public:
    Car(string c, int s, int door)
        : Vehicle(c, s), doorCount(door) {}

    void openDoor() {
        cout << doorCount << " doors are available." << endl;
    }
};

// 비행기
class Airplane : public Vehicle {
private:
    int altitude;

public:
    Airplane(string c, int s, int alt)
        : Vehicle(c, s), altitude(alt) {}

    void fly() {
        cout << "Flying at " << altitude << " meters." << endl;
    }
};

int main() {
    Bicycle bicycle("Yellow", 20, true);
    Car car("Black", 100, 4);
    Airplane airplane("White", 800, 10000);

    bicycle.move();
    bicycle.ringBell();
    bicycle.showBasket();

    cout << endl;

    car.move();
    car.openDoor();

    cout << endl;

    airplane.move();
    airplane.fly();

    cout << endl;

    bicycle.stop();
    car.stop();
    airplane.stop();

    return 0;
}

II. 다형성 (Polymorphism)

1) 다형성의 필요성

① 다형성을 적용하지 않은 코드

class Lion
{
public:
	void bark() { cout << "Lion 아아아아아아" << endl; }
};

class Wolf
{
public:
	void bark() { cout << "Wolf 아우우우우우우" << endl; }
};

void print(Lion lion)
{
	lion.bark();
}

void print(Wolf wolf)
{
	wolf.bark();
}

int main()
{
	Lion lion();
	Wolf wolf();

	print(lion);
	print(wolf);

	return 0;
}

class가 더 늘어나면 print 함수도 새로 더 만들어줘야 함 -> 비효율적임

② 다형성을 적용한 코드

class Animal
{
public:
	Animal() {}
	virtual void bark() {};
};

class Lion : public Animal
{
public:
	void bark() { cout << "Lion 아아아아아아" << endl; }
};

class Wolf : public Animal
{
public:
	void bark() { cout << "Wolf 아우우우우우우" << endl; }
};

class Dog : public Animal
{
public:
	void bark() { cout << "Dog 멍멍" << endl; }
};

void print(Animal* animal)
{
	animal->bark();
}

int main()
{
	Lion lion();
	Wolf wolf();
	Dog dog();

	print(&lion);
	print(&wolf);
	print(&dog);

	return 0;
}

부모 클래스를 만들어서 자식 클래스를 모두 다룰 수 있음

2) 가상 함수 (Virtual Function)

다형성에서 가장 중요한 키워드

virtual void bark()
{
}

① virtual을 사용하는 경우

동적 바인딩: 실행 중에 실체 객체가 무엇인지 확인 후 해당 함수 호출하는 기능

Animal*
↓
동적 바인딩
(실제 객체 확인
↓
Dog인가?
↓
Dog::bark() 호출)

Dog::bark()가 호출됨

② virtual을 사용하지 않는 경우

Animal* animal;
Dog dog;

animal = &dog;

animal->bark();
↓
Animal::bark() 호출

dog의 주소를 가리켜도 Animal::bark()가 호출됨

3) 재정의 (Override)

부모의 함수를 자식에서 다시 구현하는 것

class Animal
{
public:
    virtual void sound()
    {
        cout << "Animal";
    }
};

class Dog : public Animal
{
public:
    void sound() override
    {
        cout << "멍멍";
    }
};

override는 부모 함수를 재정의하는 것이 맞는지 컴파일러가 확인해주는 역할

4) 순수 가상 함수 (Pure Virtual Function)

기본 클래스가 함수를 아예 구현하지 않음

virtual void sound() = 0;

인터페이스만 제공, 구현은 자식 클래스에서 함

일반 가상 함수는 구현을 하고, 재정의는 자식 클래스에서 여부를 선택함

순수 가상 함수는 구현을 하지 않고, 재정의를 반드시 해줘야 함

5) 추상 클래스 (Abstract Class)

순수 가상 함수가 하나라도 있으면 추상 클래스임

class Animal
{
public:
    virtual void sound() = 0;
};

Animal animal; (불가능)

Animal *animal;
animal = &dog; (가능)

Animal은 인터페이스만 있을 뿐 이제 더 이상 인스턴스화가 될 수 없음

6) 추상 클래스 활용 예시

#include <iostream>
using namespace std;

// 기본 클래스 (추상 클래스)
class Skill {
public:
    virtual void use() = 0;
};

// 파생 클래스 : Fireball
class Fireball : public Skill {
public:
    void use() override {
        cout << "Fireball! Deal 100 fire damage." << endl;
    }
};

// 파생 클래스 : Heal
class Heal : public Skill {
public:
    void use() override {
        cout << "Heal! Recover 80 HP." << endl;
    }
};

// 파생 클래스 : Dash
class Dash : public Skill {
public:
    void use() override {
        cout << "Dash! Move quickly forward." << endl;
    }
};

int main() {
    Skill* skill;

    Fireball fireball;
    Heal heal;
    Dash dash;

    skill = &fireball;
    skill->use();

    skill = &heal;
    skill->use();

    skill = &dash;
    skill->use();

    return 0;
}

개념 정리 - C++(클래스)

journey46110 — Fri, 10 Jul 2026 20:27:28 +0900

클래스 (Class)

1) 클래스가 필요한 이유

클래스가 없을 때의 예시 - 학생의 성적을 관리하는 프로그램

int korean = 90;
int english = 80;
int math = 100;

float GetAverage(int kor, int eng, int math);
int GetMax(int kor, int eng, int math);

과목 추가 -> 함수의 매개 변수 수정 필요
학생이 여러 명 -> 변수가 많아짐

점수를 아무 곳에서나 수정할 수 있음

- 데이터와 기능이 따로 놀기 때문에 유지보수가 어려움

2) 클래스의 정의

- 관련된 데이터(변수)와 기능(함수)을 하나로 묶어 놓은 설계도

- 클래스를 호출할 때 세부사항은 몰라도 되고, 기능만 이해하고 작동하면 됨

3) 클래스의 구성

class Student
{
private:
    int korean;
    int english;
    int math;

public:
    float GetAverage();
    int GetMaxScore();
};

① 멤버 변수 (Member Variable)

- 데이터

int korean;
int english;
int math;

② 멤버 함수 (Member Function)

- 동작

GetAverage();
GetMaxScore();

4) 객체 (Object)

- 클래스는 설계도에 해당함

Student s1;
Student s2;
Student s3;

- 실제로 사용하는 것은 이렇게 만든 객체임

5) 멤버 접근 연산자 (.)

- 객체 안의 변수나 함수는 . 으로 접근함

Student s;

s.GetAverage();

6) 접근 제어자

① public

- 누구나 접근 가능함

public:
    void Print();

② private

- 클래스 내부에서만 접근 가능함

- 아무 곳에서나 변수를 수정할 수 있으면 프로그램이 망가짐

- 직접 수정은 막고 함수를 통해서만 수정할 수 있게 함

private:
    int score;

Student s;

s.score = 100; //에러 발생

7) Getter / Setter

① Getter

- 값을 가져오는 함수

int GetScore()
{
    return score;
}

② Setter

- 값을 변경하는 함수

- 보통 검사를 같이 함

void SetScore(int s)
{
    if(s >= 0 && s <= 100)
        score = s;
}

- private를 사용하는 가장 큰 이유

8) 생성자 (Constructor)

- 객체가 만들어질 때 자동으로 호출되는 함수

① 자동으로 호출되는 함수

- 반환형이 없음

- 이름이 클래스와 같음

Student()
{
}

② 기본 생성자

- 자동 호출

Student()
{
    score = 0;
}

Student s;

③ 매개변수 생성자

- 매개변수를 받음

- 매개변수를 지정하지 않으면 에러가 발생함

Student(int s)
{
    score = s;
}

Student s(100);

④ 기본값 생성자

- 매개변수를 지정하지 않으면 기본값이 설정됨

Student(int s = 100)
{
    score = s;
}

Student s1;
Student s2(50);

9) 클래스 내부 구현과 외부 구현

① 내부 구현

- 간단한 함수에 적합함

- 함수를 클래스 내부에서 구현함

class Student
{
public:

    void Print()
    {
        cout << "Hello";
    }
};

② 외부 구현

- 헤더(.h)와 cpp를 분리하고, cpp에서 함수를 구현함

- 실무에서 대부분 사용하는 방식임

헤더 파일

class Student
{
public:
    void Print();
};

cpp 파일

#include "Student.h"

void Student::Print()
{
    cout << "Hello";
}

main 함수

#include "Student.h"

int main()
{
    Student s;
    s.Print();
}

10) include Guard

- 헤더가 여러 번 include되는 것을 막음

- 한 번 정의하는 과정을 거친 클래스는 다음에 정의하는 과정을 무시함

#ifndef STUDENT_H
#define STUDENT_H

class Student
{
};

#endif

11) 클래스의 특성

① 캡슐화

- 데이터와 기능을 하나로 묶음

Student
├── score
├── name
├── GetAverage()
└── Print()

② 정보 은닉

- 필요한 것만 공개함

public
↓
사용 가능

private
↓
숨김

③ 재사용성

- 한 번 만든 클래스를 여러 번 사용할 수 있음

Student a;
Student b;
Student c;
Student d;

④ 유지보수성

- 기능을 수정해도 클래스를 사용하는 코드는 거의 수정하지 않음

11) 배터리 관리 클래스 만들기

① 기본값을 가진 생성자 만들기

- 배터리 잔량의 기본값은 100

- 0보다 작은 숫자와 100보다 큰 숫자의 예외처리를 함

Battery(int initialCharge = 100) {
    charge = initialCharge;

    if (charge < 0) {
        charge = 0;
    }
    else if (charge > 100) {
        charge = 100;
    }

② 배터리 잔량을 반환하는 함수

 int getCharge() const {
     return charge;
 }

③ 배터리를 사용하는 함수

- 한 번 사용할 때마다 5씩 감소함

 void useBattery() {
     if (charge >= 5) {
         charge -= 5;
     }
     else {
         charge = 0;
     }
     std::cout << "Battery used. Current charge: " << charge << "%\n";
 }

④ 배터리를 충전하는 함수

- 한 번 충전할 때마다 7씩 증가함

void chargeBattery() {
    if (charge <= 93) {
        charge += 7;
    }
    else {
        charge = 100;
    }
    std::cout << "Battery charged. Current charge: " << charge << "%\n";
}

⑤ 코드 예시

#include <iostream>

class Battery {
private:
    int charge; // 배터리 잔량

public:
    // 생성자: 기본값은 100으로 설정
    Battery(int initialCharge = 100) {
        charge = initialCharge;

        if (charge < 0) {
            charge = 0;
        }
        else if (charge > 100) {
            charge = 100;
        }
    }

    // 배터리 잔량 반환
    int getCharge() const {
        return charge;
    }

    // 배터리를 사용하여 잔량 감소
    void useBattery() {
        if (charge >= 5) {
            charge -= 5;
        }
        else {
            charge = 0;
        }
        std::cout << "Battery used. Current charge: " << charge << "%\n";
    }

    // 배터리를 충전하여 잔량 증가
    void chargeBattery() {
        if (charge <= 93) {
            charge += 7;
        }
        else {
            charge = 100;
        }
        std::cout << "Battery charged. Current charge: " << charge << "%\n";
    }
};

void usingbattery() {
    // 배터리 객체 생성 (초기 잔량 100)
    Battery battery;

    std::cout << "Initial charge: " << battery.getCharge() << "%\n";

    // 배터리 사용 및 충전 테스트
    battery.useBattery(); // 잔량 95%
    battery.useBattery(); // 잔량 90%
    battery.chargeBattery(); // 잔량 97%
    battery.useBattery(); // 잔량 92%
}

12) 두 분수의 곱셉을 할 수 있는 클래스 만들기

① 기본값을 가진 생성자 만들기

- 분자의 기본값은 0, 분모의 기본값은 1임

- 분모에 0이 들어오면 1로 바꿔줌

Fraction(int num = 0, int denom = 1) {
    numerator = num;
    denominator = (denom != 0) ? denom : 1; // 분모가 0이면 1로 설정
}

② 유클리드 호제법으로 최대공약수를 구하는 함수

int gcd(int a, int b) const {
    while (b != 0) {
        int temp = b; // 현재 b 값을 저장
        b = a % b;    // a를 b로 나눈 나머지를 새로운 b로 설정
        a = temp;     // 이전 b 값을 새로운 a로 설정
    }
    return a; // b가 0이 되었을 때 a가 최대공약수
}

③ 최대공약수를 이용해 분수를 기약분수로 바꿔주는 함수

void simplify() {
    int gcdValue = gcd(numerator, denominator); // 분자와 분모의 최대공약수 계산
    numerator /= gcdValue;   // 분자를 최대공약수로 나누기
    denominator /= gcdValue; // 분모를 최대공약수로 나누기
}

④ 두 분수를 곱하는 함수

Fraction multiply(const Fraction& other) const {
    // 새로운 분자 = 현재 분수의 분자 * 다른 분수의 분자
    int newNumerator = numerator * other.numerator;

    // 새로운 분모 = 현재 분수의 분모 * 다른 분수의 분모
    int newDenominator = denominator * other.denominator;

    // 새로운 Fraction 객체 생성
    Fraction result(newNumerator, newDenominator);

    // 결과를 간단히 만들기
    result.simplify();

    return result;
}

⑤ 분수를 출력하는 함수

void display() const {
    cout << numerator << "/" << denominator;
}

⑥ 코드 예시

#include <iostream>
using namespace std;

// Fraction 클래스 정의
// 분수를 표현하고 곱셈 및 단순화 기능을 제공합니다.
class Fraction {
private:
    int numerator;   // 분자
    int denominator; // 분모

    // 최대공약수를 계산하는 유클리드 호제법 구현
    // gcd 함수는 Fraction 클래스 내부에서만 사용되므로 private으로 설정
    int gcd(int a, int b) const {
        while (b != 0) {
            int temp = b; // 현재 b 값을 저장
            b = a % b;    // a를 b로 나눈 나머지를 새로운 b로 설정
            a = temp;     // 이전 b 값을 새로운 a로 설정
        }
        return a; // b가 0이 되었을 때 a가 최대공약수
    }

public:
    // 매개변수가 있는 생성자
    // 사용자로부터 분자와 분모를 입력받아 초기화합니다.
    // 분모가 0일 경우 자동으로 1로 설정합니다. (분모가 0이면 정의되지 않음)
    Fraction(int num = 0, int denom = 1) {
        numerator = num;
        denominator = (denom != 0) ? denom : 1; // 분모가 0이면 1로 설정
    }

    // 분수를 간단한 형태로 변환하는 함수
    // 최대공약수(gcd)를 이용해 분자와 분모를 나눕니다.
    void simplify() {
        int gcdValue = gcd(numerator, denominator); // 분자와 분모의 최대공약수 계산
        numerator /= gcdValue;   // 분자를 최대공약수로 나누기
        denominator /= gcdValue; // 분모를 최대공약수로 나누기
    }

    // 두 분수를 곱하는 함수
    // 두 분수를 곱한 새로운 분수를 반환합니다.
    Fraction multiply(const Fraction& other) const {
        // 새로운 분자 = 현재 분수의 분자 * 다른 분수의 분자
        int newNumerator = numerator * other.numerator;

        // 새로운 분모 = 현재 분수의 분모 * 다른 분수의 분모
        int newDenominator = denominator * other.denominator;

        // 새로운 Fraction 객체 생성
        Fraction result(newNumerator, newDenominator);

        // 결과를 간단히 만들기
        result.simplify();

        return result;
    }

    // 분수를 출력하는 함수
    // 분자를 '/' 기호와 함께 출력합니다.
    void display() const {
        cout << numerator << "/" << denominator;
    }
};

void fraction(void) {
    // 두 분수 생성
    Fraction f1(1, 2); // 첫 번째 분수: 1/2
    Fraction f2(3, 4); // 두 번째 분수: 3/4

    // 두 분수를 곱하기
    Fraction product = f1.multiply(f2); // f1 * f2

    // 결과 출력
    cout << "곱한 결과: ";
    product.display(); // 결과 분수 출력
    cout << endl;
}

개념 정리 - C++(포인터와 레퍼런스)

journey46110 — Thu, 9 Jul 2026 15:44:38 +0900

I. 포인터 (Pointer)

1) 포인터의 정의

- 변수의 메모리 주소를 저장하는 변수

int num = 10;
int* ptr = &num;

ptr에는 num의 주소가 들어 있음

2) 포인터를 사용하는 이유

① 큰 데이터를 복사하지 않아도 됨

- 값을 복사하면 데이터 크기만큼 복사 비용이 발생함

int       → 4Byte
double    → 8Byte
char      → 1Byte

- int arr[1000000]; 과 같이 큰 배열을 복사하면 매우 비효율적임

- 포인터는 주소 하나(8Byte)만 전달하면 되어서 매우 빠름

② 원본 데이터를 직접 수정할 수 있음

int num = 10;
int* ptr = &num;

*ptr = 20;

결과: num == 20

3) 주소 연산자 (&)

- 변수의 주소를 얻음

int num = 10;

cout << &num;

결과: num의 주소가 출력됨

4) 역참조 연산자 (*)

- 포인터가 가리키는 실제 값을 읽거나 수정함

int num = 10;

int* ptr = &num;

cout << *ptr;

*ptr = 30;

cout << *ptr;

결과: 각각 10, 30 출력

5) 포인터 선언과 초기화

- 포인터 타입은 가리키는 변수의 타입을 의미함

int* p;     //4Byte
char* p;    //1Byte
double* p;  //8Byte

- 포인터 타입을 알고 있어야 주소에서 몇 byte를 읽을 지 알 수 있음

int* ptr = nullptr;     //아무 것도 가리키지 않음을 의미함

- 초기화 되지 않은 포인터는 예기치 않은 오류를 일으킬 수 있음

- 반드시 nullptr로 초기화하는 습관이 중요함

6) 포인터의 크기

- 포인터의 크기는 타입과 관계없이 모두 동일함

sizeof(int*)
sizeof(char*)
sizeof(double*)

- 모두 8Byte (64bit 운영체제 기준, 32bit 운영체제에서는 4Byte)

7) 배열과 포인터의 유사성

① 배열 이름은 첫 번째 원소의 주소를 의미함

int arr[3];

// arr == &arr[0]

② []는 포인터 연산과 같음

arr[2] == *(arr + 2)

arr[i] == *(arr + i)

③ 배열 이름은 변경할 수 없음

arr = other; //불가능

- 배열 이름은 상수 포인터처럼 동작함

- 배열 이름이 바뀌게 되면 원소에 임의접근 할 수 없음

8) 포인터 연산

- 포인터는 주소를 이동함

ptr + 1               //주소 이동

int* -> 4Byte 이동
char* -> 1Byte 이동
double* -> 8Byte 이동

9) 포인터 배열과 배열 포인터

① 포인터 배열

- 포인터를 여러 개 저장하는 배열

int a = 10, b = 20, c = 30;
int* ptrArr[3] = {&a, &b, &c};

cout << *ptrArr[0] << endl;       //10 출력
cout << *ptrArr[1] << endl;       //20 출력
cout << *ptrArr[2] << endl;       //30 출력

메모리 구조

a = 10
b = 20
c = 30
┌──────┐
│ 10 │  ← a
└──────┘
┌──────┐
│ 20 │  ← b
└──────┘
┌──────┐
│ 30 │  ← c
└──────┘

ptrArr
┌────────┐
│ &a │
├────────┤
│ &b │
├────────┤
│ &c │
└────────┘

② 배열 포인터

- 배열 전체를 가리키는 포인터

int arr[3] = { 100, 200, 300 };
int (*ptr)[3] = &arr; // 배열 포인터 선언

cout << (*ptr)[0] << endl;    //100 출력
cout << (*ptr)[1] << endl;    //200 출력
cout << (*ptr)[2] << endl;    //300 출력

메모리 구조

arr
┌──────┬──────┬──────┐
│ 100 │ 200 │ 300 │
└──────┴──────┴──────┘
^
|
ptr

- 주로 다차원 배열에서 사용함

int arr[3][4];

int (*ptr)[4] = arr;

10) 포인터 사용 정리

① 일반 변수를 포인터로 가리킬 때

int a = 5;
int* ptr = &a;

*ptr = 10;        // a == 10

ptr -> 주소
*ptr -> 값

② 배열을 포인터로 받을 때

int arr[3] = {1, 2, 3};

int* ptr = arr;       // ptr[i] == *(ptr + i)

arr은 &arr[0]으로 ptr에 주소를 전달하고 있음
ptr[0]은 이미 내부적으로 *가 들어있음 -> *ptr[0]을 하면, *(*(ptr+0))이 되어서 오류가 발생함

③ 포인터 배열

int a = 10;
int b = 20;
int c = 30;

int* ptr[3] = {&a, &b, &c};

ptr[0]의 타입은 int*
ptr[i] -> 주소

*ptr[i] -> 값

④ 배열 포인터

int arr[3] = {1,2,3};

int (*ptr)[3] = &arr;

ptr은 배열 전체를 가리키는 포인터

*ptr은 arr이 됨 -> (*ptr)[i]는 arr[i]이 됨

arr과 &arr의 차이

int arr = {1, 10, 100};

&arr[0] + 1 == 10을 가지는 주소를 가리킴 //int*라면 4byte만큼 이동함
&arr + 1 == 배열 밖의 주소를 가리킴      //int*라면 4byte * 3 해서 12byte만큼 이동함

가리키는 주소는 같지만, 포인터 연산을 할 때 차이가 남

II. 레퍼런스 (Reference)

1) 레퍼런스의 정의

- 기존 변수의 별명(Alias)

- 선언과 동시에 무조건 초기화해야함

int num = 10;

int& ref = num;

num과 ref는 같음

2) 값 변경

ref = 30;

cout << num << endl;

30이 출력됨

3) 포인터와 레퍼런스의 차이

포인터	레퍼런스
주소 저장	변수의 별명
재연결 가능	재연결 불가
nullptr 가능	nullptr 불가
*,& 사용	일반 변수처럼 사용

포인터

int num = 10;

int* ptr = &num;

*ptr = 20;

레퍼런스

int num = 10;

int& ref = num;

ref = 20;

- 문법이 간단함

4) 상수 레퍼런스 (const reference)

- 읽기만 가능하고 수정은 불가능함

const int& ref = num;

cout << ref;          // 가능
ref = 30;             // 불가능

복사 비용 없이 데이터를 읽을 때 사용함

개념 정리 - C++(조건문과 반복문)

journey46110 — Wed, 8 Jul 2026 20:23:35 +0900

I. 조건문 (Conditional Statement)

1) 조건문의 정의

- 조건의 참(true) / 거짓(false)에 따라 실행할 코드를 결정하는 문법

- 프로그램의 흐름을 분기할 때 사용

2) if문

if (score >= 60)   //조건식
{
    cout << "합격";
}

- 조건식이 참이면 실행

- 거짓이면 아무것도 하지 않음

3) if-else문

if (num % 2 == 0)
{
    cout << "짝수";
}
else
{
    cout << "홀수";
}

- 조건식이 참이면 if의 실행문을 작동함

- 거짓이면 else의 실행문을 작동함

- 둘 중 하나만 실행

4) if-else if-else문

if (score >= 90)
    cout << "A";
else if (score >= 80)
    cout << "B";
else if (score >= 70)
    cout << "C";
else
    cout << "F";

- 위에서부터 차례대로 조건을 검사함

- 가장 먼저 참이 되는 조건의 실행문을 작동함

- 불필요한 else를 줄이고, else if를 사용하면 가독성이 좋아짐

5) 복합 조건

① AND (&&)

- 모든 조건이 참이어야 참으로 판단

if (score >= 60 && attendance >= 80)

② OR (||)

- 하나의 조건만 참이어도 참으로 판단

if (age < 8 || age >= 65)

6) switch문

- 하나의 변수나 식의 값에 따라 여러 경우(case) 중 하나를 선택하여 실행하는 조건문

- if-else if를 대신하여 값을 비교하는 경우에 많이 사용함

char op = '+';

switch (op)
{
    case '+':
        cout << "덧셈";
        break;

    case '-':
        cout << "뺄셈";
        break;

    case '*':
        cout << "곱셈";
        break;

    case '/':
        cout << "나눗셈";
        break;

    default:
        cout << "잘못된 연산자";
}

switch의 값 확인 -> 일치하는 case 확인 -> 해당 case부터 실행 -> break를 만나면 종료

- default는 else와 똑같은 역할을 함

- 일부러 break를 쓰지 않는 경우도 있음 (fall-through)

II. 반복문 (Loop)

1) 반복문의 정의

- 같은 작업을 여러 번 반복할 때 사용하는 문법

- 대표적으로 for, while이 있음

2) for문

- 주로 반복 횟수가 명확할 때 사용함

for (int i = 1; i <= 5; ++i) //--i도 가능
{
    cout << i << endl;
}

for (int i = 1; i <= 20; ++i)
{
    if (i % 3 == 0)
        cout << i << endl;
}

초기화 -> 조건 검사 -> 실행 -> 증감 -> 조건 검사 -> ... 의 순서로 실행됨

3) 중첩 반복문

- 반복문 안에 반복문을 넣는 것

예시

#include <iostream>
using namespace std;

void printDiamond() {
    int num;

    do {
        cout << "입력: ";
        cin >> num;

        if (num <= 1) {
            cout << "2 이상의 수를 입력하세요" << endl;
        }
    } while (num <= 1);

    for (int row = 1; row <= num; ++row) { //중첩 반복문
        for (int space = 1; space <= num - row; ++space) cout << " ";
        for (int star = 1; star <= 2 * row - 1; ++star) cout << "*";
        cout << endl;
    }

    for (int row = num - 1; row >= 1; row--) { //중첩 반복문
        for (int space = 1; space <= num - row; ++space) cout << " ";
        for (int star = 1; star <= 2 * row - 1; ++star) cout << "*";
        cout << endl;
    }
}

4) while문

- 주로 반복 횟수를 모를 때 사용함

while (num != 0)
{
    cin >> num;
}

조건 검사 -> 실행 -> 조건 검사 -> 실행 -> ... 의 순서로 실행됨

무한 반복

while (true)
{
}

- break나 return으로 탈출 가능

- break는 해당 반복문만 종료시키고, return은 해당 함수를 종료시킴

5) do-while문

- 실행문을 일단 한 번 실행을 한 후 조건을 검사함

#include <iostream>

using namespace std;

void gradeArray(void) {
	const int studentCount = 5;
	double score[studentCount] = {};
	double totalScore = 0;                                          //총합
	double avgScore;                                                //평균

	for (int i = 0; i < studentCount; i++) {
		do {                                //do-while문, 실행 한 번을 먼저함
			cout << i + 1 << "번째 학생 점수를 입력하세요 (0~100): ";
			cin >> score[i];

			if (score[i] < 0 || score[i] > 100)
				cout << "잘못된 점수입니다. 0~100 사이의 점수를 입력하세요" << endl;
		} while (score[i] < 0 || score[i] > 100);
		totalScore += score[i];
	}

	avgScore = totalScore / studentCount;

	cout << "총점: " << totalScore << endl;
	cout << "평균: " << avgScore << endl;
}

실행 -> 조건 검사 -> 실행 -> ... 의 순서로 실행됨

개념 정리 - C++(배열과 함수)

journey46110 — Wed, 8 Jul 2026 16:23:13 +0900

I. 배열 (Array)

1) 배열의 정의

- 같은 자료형의 여러 데이터를 하나의 이름으로 관리하는 자료구조

배열을 사용하지 않을 때

int score1;
int score2;
int score3;
int score4;
int score5;

배열을 사용할 때

int score[5];

- 효율적인 관리 가능

2) 배열의 구조

int score[5];

자료형 int

변수 이름 score

원소 개수 [5]

메모리 내부 모습

score
┌────┬────┬────┬────┬────┐
│ │ │ │ │ │
└────┴────┴────┴────┴────┘
0 1 2 3 4

3) 인덱스 (Index)

- 배열은 0부터 시작함

score[0] = 90;
score[1] = 85;
score[2] = 100;
score[3] = 70;
score[4] = 95;

세 번째 점수가 100이 됨

4) 임의 접근

- 배열은 원하는 위치로 바로 접근할 수 있음

score[4]

바로 5번째 점수를 불러올 수 있음

5) 배열의 초기화

① 선언과 동시에 초기화

int score[5] = {90,80,70,60,50};

② 전부 0으로 초기화

int score[5] = {};

6) 배열의 입출력

① 입력

- 배열은 변수처럼 한 번에 복사할 수 없어서, 반복문을 써서 일일히 대입해줘야 함

불가능

int score1[2] = {80, 90};

int score2[2];

score2 = score1; //불가능

가능

for(int i=0;i<5;i++)
{
    cin >> score[i];
}

② 출력

for(int i=0;i<5;i++)
{
    cout << score[i] << endl;
}

7) 배열의 길이

- 배열의 크기는 자료형의 크기 x 인덱스의 개수임

- 배열의 크기를 인덱스 하나의 크기로 나누면 배열의 길이가 됨

sizeof(score) / sizeof(score[0])

예시

int scoreLength = sizeof(score) / sizeof(score[0]);

8) 성적 관리 프로그램 구현

① 변수 선언

double score[5];

② 입력

cin >> score[0];
cin >> score[1];
cin >> score[2];
cin >> score[3];
cin >> score[4];

③ 연산

totalScore += score[0];
totalScore += score[1];
totalScore += score[2];
totalScore += score[3];
totalScore += score[4];

avgScore = totalScore / 5

④ 출력

cout << "총점: " << totalScore << endl;
cout << "평균: " << avgScore << endl;

⑤ 예시

#include <iostream>

using namespace std;

void gradeArray(void) {
	const int studentCount = 5;
	double score[studentCount] = {};
	double totalScore = 0;            //총합
	double avgScore;                  //평균

	for (int i = 0; i < studentCount; i++) {
		do {
			cout << i + 1 << "번째 학생 점수를 입력하세요 (0~100): ";
			cin >> score[i];

			if (score[i] < 0 || score[i] > 100)
				cout << "잘못된 점수입니다. 0~100 사이의 점수를 입력하세요" << endl;
		} while (score[i] < 0 || score[i] > 100);
		totalScore += score[i];
	}

	avgScore = totalScore / studentCount;

	cout << "총점: " << totalScore << endl;
	cout << "평균: " << avgScore << endl;
}

II. 함수 (Function)

1) 함수의 정의

- 특정 작업을 수행하도록 이름을 붙인 코드 묶음

예시 - 두 수를 더하는 작업

int add(int a, int b)
{
    return a+b;
}

호출

add(3, 5);

2) 함수를 사용하는 이유

- 반복되는 코드를 여러 번 쓰는 대신, 한 번만 만들어 놓고 계속 쓸 수 있음

장점

① 코드 재사용 가능

② 유지보수 쉬움

③ 가독성 향상

3) 함수의 구성

int add(int num1, int num2)
{
    return num1 + num2;
}

반환형 int

함수 이름 add

매개변수(Parameter) int num1, int num2

내부 코드 { return num1 + num2; }

4) 함수 호출

int result = add(3,5);

3과 5를 인자로 add 함수를 호출해서 8을 return함

5) 반환값이 없는 함수

void Print()
{
    cout<<"Hello";
}

- 반환형이 void인 함수는 아무 것도 반환하지 않음

- return 생략

6) 값 전달 방식

① 값 전달 (Call by Value) - 원본 변경 X

void AddOne(int x)
{
    x++;
}

int num=10;

AddOne(num);

결과 num = 10

- 인자로 변수를 넘겨주면 값을 복사해서 전달하는 방식이라 num이 변하지 않음

② 주소 전달 (Call by Address) - 원본 변경 O

void AddOne(int* x)
{
    (*x)++;
}

int num = 10;

AddOne(&num);

결과 num = 11

- 인자로 원본 변수의 메모리 주소를 넘겨주고, 함수 내부에서 포인터 연산자를 통해서 메모리 주소에 접근해서 값을 바꿈

③ 배열 전달 - 원본 변경 O

void Print(int* ptr)
{
    ptr[0] = 4;
}

int arr[4] = {1, 2, 3, 4};

Print(arr);

결과 arr[0] = 4

- 인자로 배열을 복사할 때, 배열 첫 번째 인덱스의 메모리 주소도 같이 복사함

- 이를 통해, 함수 내부에서 배열을 바꾸면 원본도 바뀜

④ 참조 전달 (Call by Reference) - 원본 변경 O

void AddOne(int& x)
{
    x++;
}

int num = 10;

AddOne(num);

결과 num = 11

- & 연산자를 사용하면 레퍼런스를 생성함

- 원본의 별명을 지어주는 것과 같음

개념 정리 - C++(변수와 입출력)

journey46110 — Wed, 8 Jul 2026 12:41:23 +0900

변수와 입출력

1) C++ 프로그램의 기본 구조

- 모든 C++ 프로그램은 main() 함수에서 시작됨

#include <iostream>

using namespace std;

int main() {
    cout << "Hello, World!" << endl;
    return 0;
}

구성	설명
#include <iostream>	입출력 기능(cin, cout)을 사용하기 위한 헤더
using namespace std;	std::를 생략하기 위해 사용
int main()	프로그램의 시작점(진입점)
return 0;	프로그램이 정상 종료되었음을 운영체제에 알림

2) 변수 (Variable)

- 데이터를 저장하기 위해 메모리에 이름을 붙여 놓은 공간

int age = 20;

예시) 메모리에는 정수 하나가 저장되고, 그 공간의 이름이 age가 됨

- 자료형 + 변수 이름으로 구성

int score;
char grade;
double average;

3) 자료형 (Data Type)

- 저장할 데이터의 종류와 메모리 크기를 결정함

자료형	저장 데이터	저장 공간	예시
int	정수	4 byte	10, -5
float	실수(단정밀도)	4 byte	3.14f
double	실수(배정밀도)	8 byte	3.141592
char	문자 1개	1 byte	'A'
bool	참/거짓	1 byte	true
string	문자열		"Hello"
unsigned int	양의 정수	4 byte	0 ~ 큰 양수

- unsigned는 부호 비트를 사용하지 않고 모든 비트를 숫자 표현에 사용한다.

- 따라서, 음수는 표현할 수 없지만, 양수(0 포함)의 표현 범위가 signed보다 약 2배 넓어진다.

int
-2,147,483,648
~
2,147,483,647

unsigned int
0
~
4,294,967,295

4) 변수 선언과 초기화

① 선언을 통해 메모리만 확보하고, 나중에 값을 대입하는 경우

int num;
num = 10;

② 선언과 동시에 초기화하는 경우

int num = 10;

5) 출력과 입력

① 출력 cout

cout << "점수 : " << score << endl;

② 입력 cin

- 사용자가 입력한 값을 변수에 저장

cin >> score;

6) 연산자

① sizeof 연산자

- 변수나 자료형의 메모리 크기를 알려줌

int num;

cout << sizeof(num);

- 사용법 두 가지

sizeof(int)
sizeof(num)

② 산술 연산자

연산자	의미
+	덧셈
-	뺄셈
*	곱셈
/	나눗셈
%	나머지

int a = 10;
int b = 3;

a + b   //13
a - b   //7
a * b   //30
a / b   //3, 정수끼리 나누면 몫만 남고 소수점은 버림
a % b   //1

③ 비교 연산자

- 비교 결과는 항상 true 아니면 false임

연산자	의미
==	같다
!=	다르다
>	크다
<	작다
>=	이상
<=	이하

5 == 5

④ 대입 연산자

- 기본 대입, ==와 =를 헷갈리면 안 됨

a = 10;

- 복합 대입, 코드를 간결하게 만들어줌

a += 3;
a -= 3;
a *= 3;
a /= 3;
a %= 3;

↓

a = a + 3;
a = a - 3;
a = a * 3;
a = a / 3;
a = a % 3;

⑤ 증감 연산자

- 후위 증가, 변수를 대입한 후 증감함

int a = 5;
int b = a++;

↓

a = 6
b = 5

- 전위 증가, 변수를 증감한 후 대입함

int a = 5;
int b = ++a;

↓

a = 6
b = 6

7) 계산기 구현

① 변수 선언

int num1;
int num2;

② 입력

cin >> num1;
cin >> num2;

③ 연산

num1 + num2
num1 - num2
num1 * num2
num1 / num2
num1 % num2

④ 출력

cout << num1 + num2 << endl;

⑤ 예시

#include <iostream>
using namespace std;

void Calculate(void) {
	int num1;
	int num2;
	char op;
	char menu;

	while (true) {
		cout << "첫 번째 수 입력: ";
		cin >> num1;
		cout << "두 번째 수 입력: ";
		cin >> num2;
		cout << "연산자 입력: ";
		cin >> op;

		switch (op) {
			case '+':
				cout << num1 << " + " << num2 << " = " << num1 + num2 << endl;
				break;
			case '-':
				cout << num1 << " - " << num2 << " = " << num1 - num2 << endl;
				break;
			case '*':
				cout << num1 << " * " << num2 << " = " << num1 * num2 << endl;
				break;
			case '/':
				if (num2 == 0) {
					cout << "0으로 나눌 수 없습니다" << endl;
				}
				else {
					cout << num1 << " / " << num2 << " = " << (double)num1 / num2 << endl;
				}
				break;
			case '%':
				if (num2 == 0) {
					cout << "0으로 나눌 수 없습니다" << endl;
				}
				else {
					cout << num1 << " % " << num2 << " = " << num1 % num2 << endl;
				}
				break;
			default:
				cout << "잘못된 연산자 입력입니다" << endl;
		}

		while (true)
		{
			cout << "=====================" << endl;
			cout << "1. 계산" << endl;
			cout << "2. 종료" << endl;
			cout << "=====================" << endl;
			cout << "선택 : ";

			cin >> menu;

			if (menu == '1')
				break;

			if (menu == '2')
				return;

			cout << "잘못된 입력입니다.\n";
		}
	}
}

TIL - 본캠프 6일차

journey46110 — Fri, 3 Jul 2026 17:58:54 +0900

I. Blueprint - FPS 슈팅 게임 개발 프로젝트 기능 추가 및 개선

개요

오늘은 FPS 프로젝트에 플레이 경험을 개선하는 기능들을 추가하고, 기존 시스템의 동작 방식을 조금 더 자연스럽게 수정하는 작업을 진행했다.

플레이어의 이동(앉기, 달리기), 총알 및 재장전 시스템, 아이템 획득 조건, UI 개선 등을 구현하면서 게임의 완성도를 높였고, 중복되는 블루프린트 로직을 정리하는 리팩터링도 함께 진행했다.

구현 과정

1) 힐링 포션 획득 조건 수정

기존에는 플레이어의 체력이 최대 체력이어도 힐링 포션을 획득하면 포션이 사라졌다.

이를 최대 체력이 아닐 때만 획득할 수 있도록 수정하여 불필요한 아이템 소모가 발생하지 않도록 변경했다.

Health < Max Health일 때만 포션 획득 가능

또한, 최대 체력일 때는 포션을 획득할 수 없기 때문에 플레이어의 이동을 방해하지 않도록 Static Mesh의 Collision을 NoCollision으로 변경하여 자연스럽게 통과할 수 있도록 수정했다.

콜리전 프리셋 - NoCollision

2) 총알 시스템 개선

기존 총알 아이템은 현재 장전되어 있는 탄창의 총알을 증가시키는 방식이었다. 실제 FPS 게임의 방식에 맞게 총알 아이템을 획득하면 예비탄(Reserve Ammo) 이 증가하도록 수정하였다.

총알 획득 시 ReserveAmmo 증가

또한, 게임 시작 시 현재 총알을 최대 총알 수로 설정하던 방식을 변경하여, 현재 총알(Current Ammo)은 탄창 크기(Magazine Size)를 따로 추가하고, 최대 총알(Max Ammo)은 예비탄(Reserve Ammo)으로 바꾸고 역할을 분리했다.

Set CurrentAmmo = MagazineSize

이를 통해 이후 재장전 시스템을 구현하기 위한 구조를 만들 수 있었다.

3) 재장전 기능 구현

R 키 입력 시 예비탄에서 현재 탄창으로 총알을 옮기는 재장전 기능을 구현하였다.

IA_Reload, Reload 커스텀 이벤트 생성

재장전 시에는

Reload 커스텀 이벤트

탄창이 부족한 만큼만 장전되고, 장전된 수만큼 예비탄이 감소하도록 구현하였다. 이를 통해 현재 탄창과 예비탄이 서로 연동되는 구조를 만들었다.

4) 앉기(Crouch) 기능 구현

Ctrl 키 입력을 이용하여 앉기 기능을 추가하였다.

앉으면 이동 속도를 500에서 250으로 감소시키고, IsCrouched 변수를 true로 변경하였다.

Set MaxWalkSpeed 사용

키를 떼면 다시 기본 이동 속도로 복귀하고 IsCrouched를 false로 변경하도록 구현하였다.

이후 다른 이동 기능과의 상태를 판단하기 위해 IsCrouched 변수를 추가하여 관리하였다.

5) 달리기(Sprint) 기능 구현

Shift 입력 시 플레이어가 달릴 수 있도록 구현하였다.

Set MaxWalkSpeed 사용

달리는 동안 이동 속도는 800으로 증가하며 Shift를 놓으면 다시 기본 속도로 복귀한다.

또한, 앉은 상태에서는 달리기를 사용할 수 없도록 조건을 추가하여 두 상태가 동시에 적용되지 않도록 처리하였다.

6) 이동 상태 간 제약 조건 추가

이동 관련 기능이 서로 충돌하지 않도록 상태를 추가로 정리하였다.

조준과 앉기 중에는 달리기가 불가능하도록 하고, 달리는 중에는 조준과 앉기를 사용할 수 없도록 수정하였다.

이를 위해 IsAiming, IsCrouched, IsSprinting 변수를 이용하여 각각의 입력이 가능한 상황을 조건문으로 제어하였다.

덕분에 여러 입력이 동시에 발생하더라도 의도하지 않은 동작이 발생하지 않도록 만들 수 있었다.

7) 탄약 UI 개선

기존 UI는 현재 총알 수만 표시하였다.

이를 FPS 게임에서 많이 사용하는 형태인 탄창 / 예비탄 형태로 변경했다.

탄창 / 예비탄

이제 플레이어가 현재 사용할 수 있는 탄약과 남은 예비탄을 한 번에 확인할 수 있다.

8) 블루프린트 최적화

기존 For Each Loop에서는 Loop Body 안에서 반복마다 Visibility를 변경하고 있었다.

이를 Completed 핀으로 이동하여 반복이 모두 끝난 뒤 한 번만 실행하도록 변경하였다.

Completed에 Set Visibility 연결

반복 중 불필요하게 실행되던 노드를 제거하여 블루프린트의 흐름을 조금 더 효율적으로 정리할 수 있었다.

9) 중복 로직 리팩터링

게임 승리와 패배 처리에서는 동일한 종료 로직이 여러 곳에서 반복되고 있었다.

중복되던 텍스트 출력, 마우스 커서 표시, 입력 제한 등의 종료 처리를 하나의 Custom Event(EndGame) 로 분리하였다.

커스텀 이벤트 EndGame 생성

이를 통해 중복 코드를 제거하고 이후 종료 로직을 수정해야 하는 경우에도 한 곳만 수정하면 되도록 구조를 개선하였다.

후기

오늘은 새로운 기능을 추가하는 것뿐만 아니라, 여러 기능이 함께 동작할 때 발생할 수 있는 충돌을 고려하는 작업이 많았다. 특히 앉기, 달리기, 조준처럼 플레이어의 상태에 따라 사용할 수 있는 기능을 제한하면서 단순히 기능을 구현하는 것보다 상태를 어떻게 관리할지가 중요하다는 점을 다시 느꼈다.

또한, 총알 시스템도 단순히 발사 횟수를 관리하는 수준에서 벗어나 탄창과 예비탄을 분리하고 재장전 과정을 추가하면서 실제 FPS 게임과 유사한 구조로 발전시킬 수 있었다.

마지막으로, 기능 구현뿐 아니라 중복되는 블루프린트를 Custom Event로 분리하고, 반복문의 실행 흐름을 정리하는 등 유지보수를 고려한 리팩터링도 함께 진행했다. 프로젝트 규모가 커질수록 이러한 구조적인 정리가 개발 효율에 큰 영향을 준다는 점을 다시 한번 느낄 수 있었다.

TIL - 본캠프 5일차

journey46110 — Thu, 2 Jul 2026 22:39:21 +0900

I. Blueprint - FPS 슈팅 게임 개발 세션 (5회차)

개요

오늘은 FPS 프로젝트에 게임 플레이 요소를 더욱 풍부하게 만들기 위해 회복 아이템과 탄약 아이템을 추가하고, 게임 진행 상태를 관리하는 GameMode와 MainHUD를 구현하였다. 또한 제한 시간과 남은 적 수를 화면에 표시하고, 승리와 패배 조건을 설정하여 게임의 시작부터 종료까지 하나의 흐름으로 완성하였다. 마지막으로 게임 종료 시 플레이어와 적의 동작을 모두 멈추도록 개선하여 보다 자연스러운 게임 종료 화면을 구현하였다.

구현 과정

1) 회복 아이템(Healing Potion) 구현

힐링 포션

① Fab에서 빨간색 힐링 포션 메시를 프로젝트에 임포트하였다.

② Actor를 상속받는 포션 블루프린트를 생성하였다.

③ Static Mesh를 추가하여 포션 메시를 적용하였다.

④ Sphere Collision을 추가하고 충돌 범위와 메시 위치를 조정하였다.

힐링 포션 디테일

⑤ BP_Character에 AddHealth 함수를 생성하였다.

AddHealth 함수

- Heal Amount를 현재 체력에 더한다.

- Min 노드를 이용하여 최대 체력을 넘지 않도록 제한한다.

- Health를 갱신한다.

- Health / MaxHealth 값을 이용하여 HP Progress Bar를 갱신한다.

⑥ 포션 블루프린트에서는 BeginOverlap 발생 시

BeginOverlap 이벤트

- 플레이어를 캐스팅한다.

- AddHealth를 호출한다.

- 효과음을 재생한다.

- 포션을 제거한다.

⑦ 결과

Health 회복 전/후

2) 탄약 아이템 구현

탄약 아이템

① Fab에서 가져온 총알 메시를 사용하여 힐링포션과 비슷하게 탄약 아이템을 제작하였다.

② BP_Character에 AddAmmo 함수를 생성하였다.

AddAmmo 함수

- 탄약을 증가시킨 뒤 HUD의 탄약 개수를 즉시 갱신하도록 구현하였다.

③ 탄약 아이템 블루프린트에서는

BeginOverlap 이벤트

- 플레이어를 캐스팅한다.

- AddAmmo를 호출한다.

- 효과음을 재생한다.

- 총알 아이템을 제거한다.

④ 결과

총알 획득 전/후

3) 전투 시스템 구현

① 개미 BP에 체력을 저장하는 Health 변수를 생성하였다.

개미 Health 설정

② 플레이어의 Fire 함수에서 Line Trace가 적을 맞추면 Apply Damage 노드를 호출하도록 구현하였다.

Break Hit Result의 Hit Actor 사용

③ 개미 BP에서는 Event AnyDamage를 이용하여 전달받은 데미지만큼 체력을 감소시켰다.

데미지 받을 시 Health 변경

④ Health가 0 이하가 되면 적이 제거(Destroy)되도록 구현하였다.

Destroy 함수

Beginoverlap(ExplosionSphere) 이벤트 뒤에서 적 제거와 관련된 로직을 하나의 Destroy 함수로 분리하여 재사용할 수 있도록 구성하였다.

4) 개미 Animation Blueprint 구현

① 개미의 Animation Blueprint를 생성하였다.

② 개미 Skeletal Mesh의 Anim Class에 생성한 Animation Blueprint를 적용하였다.

③ Blend Space를 새롭게 생성하여 이동 속도에 따라 애니메이션이 자연스럽게 변경되도록 구성하였다.

블렌드스페이스

Idle, Walk, Run 세 가지 애니메이션 시퀀스를 배치하였다.

④ Blend Space의 가로 축 이름을 Speed로 설정하고 최대값은 600으로 지정하고, Grid Snap을 이용하여 각 애니메이션이 적절한 속도 구간에서 재생되도록 배치하였다.

⑤ Anim Graph에서 BS_Ant를 Output Pose에 연결하였다.

AnimGraph

⑥ Event Graph에서는 기존 플레이어 Animation Blueprint와 동일한 방식으로 현재 이동 속도를 계산하였다.

ABP의 이벤트그래프

⑦ 계산한 Speed 변수를 Blend Space의 Speed 입력값에 연결하였다.

5) 개미 AI 랜덤 순찰 구현

① 개미가 일정한 위치만 이동하지 않고 맵을 자유롭게 순찰하도록 MoveRandom Custom Event를 구현하였다.

MoveRandom

② AI Move To 노드를 사용하여 목적지를 설정하고, Destination에는 Get Random Reachable Point in Radius를 사용하였다.

③ 이동이 끝난 후에는 Delay 노드를 사용하여 0~3초 사이의 랜덤한 시간만큼 대기하도록 구성하였다.

④ 대기가 끝나면 MoveRandom을 다시 호출하여 랜덤 이동을 반복하도록 구현하였다.

⑤ MoveRandom과 StartChase의 AIMoveTo가 겹치지 않도록, Bool타입의 IsChasing 변수를 생성하여 Branch로 관리한다.

-> 추격하지 않을 때만 랜덤으로 이동한다.

6) 적 이동 속도 변경

① 평소 이동 속도와 플레이어를 추적할 때의 속도를 float형 변수로 관리한다.

기본 속도 / 추적 속도

② 개미가 평소 이동할 때는 Max Walk Speed를 300으로 설정하였다.

Bp_Ant의 MoveRandom 커스텀 이벤트 내부에 Set MaxWalkSpeed를 추가하고, BaseSpeed(float,300.0)을 연결했다.

Set MaxWalkSpeed 300.0

③ 플레이어를 추격할 때는 Max Walk Speed를 600으로 변경하였다.

StartChase 커스텀 이벤트 내부에 Set MaxWalkSpeed를 추가하고, ChaseSpeed(float,600.0)을 연결했다.

Set MaxWalkSpeed 600.0

④ AIMoveTo 비동기 오류 해결

AIMoveTo는 비동기로 작동한다. 기존의 StartChase는 적을 공격했을 때와 적의 탐지 범위에 overlap 됐을 때 작동했다. 만약, 개미를 공격하고 Chase 중일 때, 탐지 범위에 overlap 되면 AIMoveTo가 실패로 간주되어 MoveRandom이 작동되어 늘어난 개미의 이동 속도가 다시 300으로 초기화 되는 버그가 일어난다.

비동기 오류를 조건문으로 해결 1

비동기 오류를 조건문으로 해결 2

그렇기에, Chase와 Update Health 부분에 IsChasing이 false일 때만 StartChase 이벤트가 호출되게 변경하여 AIMoveTo 비동기 오류를 해결했다.

7) MainHUD 제작

① 게임 진행을 표시할 MainHUD를 생성하였다.

MainHUD

② Canvas Panel 위에 남은 시간, 남은 적 수, Result, 재시작 버튼, 종료 버튼을 배치하였다.

③ Result와 버튼들은 처음에는 보이지 않도록 Visibility를 Collapsed로 설정하였다.

Visibility - Collapsed

④ GameMode BeginPlay에서

MainHUD 화면에 생성

Create Widget, MainHUD 변수 저장, Add To Viewport 순으로 HUD를 생성하였다.

⑤ World Settings에서 새 GameMode를 적용하고 Default Pawn을 BP_Character로 변경하였다.

오버라이드와 디폴트 폰 클래스 변경

8) 제한 시간 시스템 구현

① GameMode에 float 타입 TimeRemaining 변수를 생성하였다.

② UpdateRemainingTime Custom Event를 생성하였다.

UpdateRemainingTime

③ Event Tick의 Delta Seconds를 전달하여 시간을 감소시켰다.

Delta Seconds 사용

④ HUD의 Time Text를 계속 갱신하도록 연결하였다.

Set Text(MainHUD - Time)

⑤ Format Text를 이용하여 시간을 분 : 초 형식으로 출력하였다.

- 분 = RemainingTime / 60

- 초 = RemainingTime % 60

각각 Floor To Integer를 사용하였다.

⑥ 결과

남은 시간 표시

9) 시간 초과 시 게임 패배 구현

① RemainingTime이 0 이하인지 Branch로 검사하였다.

② 시간이 모두 소진되면 시간을 0으로 고정하고, Result를 "게임 패배"로 변경한다.

시간 0 고정 및 게임 패배 출력

③ Result와 버튼들의 Visibility를 Visible로 변경한다.

Set Visibility - Visible

④ 플레이어 입력을 비활성화하고, Input Mode를 UI Only로 변경한다. 그리고, 마우스 커서를 표시한다.

입력 비활성화, UI 활성화, 마우스 커서 활성화

⑤ Tick에서 계속 실행되지 않도록 Do Once를 추가하였다.

⑥ 결과

시간 초과로 게임 패배

10) 게임 재시작 및 종료 버튼 구현

게임 재시작 / 종료

① Restart 버튼의 OnClicked 이벤트에서 Open Level을 호출하도록 설정하였다.

재시작 시에는 Input Mode를 다시 UI Only에서 Game Only로 바꾼다.

② Quit 버튼의 OnClicked 이벤트에서 Quit Game을 호출하도록 설정하였다.

11) 남은 적 수 관리

남은 개미의 수를 배열에 저장

① GameMode BeginPlay에서 Get All Actors Of Class(BP_Ant)를 이용하여 모든 개미를 가져왔다.

② For Each Loop를 이용하여 Ant 배열에 저장하였다.

③ 배열의 Length를 Integer 타입의 RemainingAnts 변수에 저장하였다.

④ HUD의 남은 적 수를 RemainingAnts 값으로 표시하였다.

12) 적 처치 이벤트 구현

① GameMode에 OnAntKilled Custom Event를 생성하였다.

OnAntKilled

② 이벤트 실행 시 RemainingAnts를 1 감소시키고, HUD를 갱신한다.

③ RemainingAnts가 0 이하가 되면 IsWin을 True로 변경하고, 게임 승리 HUD가 표시된다.

④ BP_Ant의 BeginPlay에서 GameMode를 캐스팅하여 변수로 저장하였다.

GameMode 변수 저장

⑤ 개미가 제거될 때마다 OnAntKilled를 호출하도록 Destroy 함수 내부에서 호출하고 연결하였다.

Destroy 함수 내부

⑥ 결과

몬스터 처치 전 / 후

13) 게임 종료 시 플레이어와 적 제어

① 게임 종료 시 플레이어의 IsFiring을 False로 변경하여 사격을 중지하였다.

Set IsFiring flase

② BP_Ant에 CanMove 변수를 추가하고, Move Random과 Start Chase에서 CanMove를 검사하도록 수정하였다.

true이면 동작 가능

③ 게임에서 승리하면

개미 움직임 제어

Ant 배열을 For Each Loop로 순회하고, 모든 개미의 CanMove를 False로 변경한다. 그 후, 개미의 Movement Mode를 None으로 변경하여 이동을 완전히 중지시켰다.

Completed 핀을 사용하여 게임 종료 UI가 한 번만 실행되도록 수정하였다.

14) 체력이 모두 소진되었을 때 게임 패배 구현

① Update Health and HUD에서 Health가 0 이하인지 검사하였다.

Health 조건 검사

② Health가 0 이하가 되면 OnHealthDepleted를 호출하도록 연결하였다.

③ OnHealthDepleted는 다른 게임 종료 방식과 구성이 같다.

④ 게임 종료 구성

게임 종료 -> 승리/혹은 패배 문구 출력 -> For Each Loop로 적 움직임 제어 -> HUD Visible -> IsFiring false로 변경, Disable Input -> Set Input Mode UI Only -> 마우스 커서 보임

후기

오늘은 아이템 시스템부터 GameMode를 이용한 게임 진행 관리, 승리 및 패배 조건, UI 제어까지 게임의 전체 흐름을 구현하는 방법을 학습하였다. 특히, GameMode가 게임 전체의 상태를 관리하는 중심 역할을 한다는 점을 이해할 수 있었으며, 플레이어와 적, HUD가 서로 연결되어 하나의 게임 시스템을 구성하는 과정을 경험할 수 있었다.

이전까지는 총 발사, AI, HUD 등 각각의 기능을 개별적으로 구현하는 데 집중했다면, 오늘은 이러한 기능들을 하나로 연결하여 실제 게임처럼 동작하는 구조를 만드는 과정을 경험할 수 있었다. 기능 간의 연결 관계를 이해하면서 게임을 구성하는 전체적인 흐름을 조금 더 넓은 시각에서 바라볼 수 있게 되었다.

또한, 게임 종료 시 Do Once를 사용하여 이벤트의 중복 실행을 방지하고, IsFiring, CanMove, Movement Mode를 활용해 플레이어와 적의 행동을 모두 멈추도록 구현하면서 게임의 완성도를 높일 수 있었다. 이번 실습을 통해 단순히 기능을 구현하는 것을 넘어 게임의 시작부터 종료까지 전체 흐름을 설계하는 방법을 익힐 수 있었고, 이후 C++에서도 이러한 구조를 구현하는 데 큰 도움이 될 것이라 생각한다.

II. C언어 세션 (5회차)

개요

오늘 학습은 C언어의 두 핵심 축인 함수 호출 방식과 포인터의 동작 원리를 중심으로 진행되었다.

단순히 “포인터 문법”이나 “함수 사용법”을 익히는 단계가 아니라,

- 왜 함수 안에서 값이 안 바뀌는지

- 왜 포인터를 써야 원본이 바뀌는지

- 배열과 포인터가 왜 비슷해 보이는지

- *, & 같은 기호가 왜 헷갈리는지

이러한 문제들의 근본 원인(메모리 구조 + 값 전달 방식)을 기준으로 다시 정리했다.

학습 내용

1) 함수에서 값이 안 바뀌는 이유

함수에 넣으면 그냥 원본이 들어간다고 착각하기 쉽지만, 실제로는 그냥 복사본이다.

void func(int x) {
    x = 100;
}

이 코드는 겉으로 보면 x를 바꾸는 것 같지만 실제로는 main의 변수와는 다른 “복사된 x”를 수정한다.

즉, C는 기본적으로 값 전달(call by value) 구조다. 그래서 원본을 바꾸려면 *를 써야 한다.

void func(int *x) {
    *x = 100;
}

2) return의 진짜 역할 (값 반환 + 함수 종료)

return은 단순히 값을 돌려주는 게 아니라 함수 즉시 종료, 이후 코드 실행 차단 두 가지 역할을 한다.

if (x < 0) return -1;

이 구조가 가능한 이유는 return이 흐름 종료 장치이기 때문이다.

3) 포인터

int x = 10;
int *p = &x;

x → 값

&x → 주소

p → 주소 저장 변수

*p → 그 주소에 있는 값

4) & 와 *의 역할이 헷갈리는 이유

이게 제일 헷갈리는 부분이다.

&	변수 앞	주소 꺼내기
*	선언	포인터 선언
*	사용	주소 따라가기

int *p = &x;

*p = &x (잘못된 해석)

p = &x (정확한 구조)

5) 배열과 포인터의 관계

int arr[5];
int *p = arr;

	배열	포인터
크기	전체 크기 존재	주소 크기만 존재
대입	불가능	가능
이동	불가능	가능

sizeof(arr);   // 전체 크기, 20
sizeof(p);     // 포인터 크기, 8

둘은 확실히 차이난다. 배열은 고정된 메모리 공간이고, 포인터는 이동 가능한 주소 변수이다.

6) 함수에 배열을 넘기면 크기가 사라진다

void func(int arr[])

이건 사실 내부적으로 아래처럼 바뀐다.

void func(int *arr)

즉, 함수 안에서는 배열의 크기를 알 수 없고, 항상 size를 따로 넘겨야 한다.

7) 포인터 연산은 바이트 이동이 아니다

p + 1

이건 단순 +1이 아니라 타입 크기만큼 이동한다.

int → 4바이트

double → 8바이트

char → 1바이트

포인터는 타입 기반 주소 이동 시스템이다.

8) NULL로 초기화

int *p;
*p = 10; // 위험

초기화 안 된 포인터는 쓰레기 주소이고, 접근하면 undefined behavior를 일으킨다.

안전하게 쓸려 이렇게 NULL로 초기화해줘야 한다.

int *p = NULL;

포인터는 반드시 어디를 가리키는지 확실해야 사용 가능하다.

9) 지역 변수와 생명주기 문제

int* func() {
    int x = 10;
    return &x;
}

x는 함수 끝나면 사라진다.

주소만 남음 (댕글링 포인터)

주소는 남아도 값은 사라질 수 있다

10) 포인터의 포인터 (**)를 쓰는 이유

int **pp;

이건 단순 확장이 아니라 포인터 자체를 바꾸고 싶을 때 쓴다.

* → 값 변경

** → 주소 자체 변경

후기

오늘 내용은 새로운 개념이라기보다는, 이미 알고 있던 것들을 다시 한 번 “왜 그렇게 동작하는지” 기준으로 정리한 느낌이었다. 특히, 함수 호출과 포인터 전달 구조는 이미 알고 있었지만, 값 전달 vs 주소 전달이 실제로 코드에서 어떻게 구분되는지 다시 보면서 정리가 됐다.

그리고 포인터 자체보다는 *가 선언과 역참조에서 의미가 달라지는 지점, 배열이 포인터로 decay되는 순간의 차이, 함수 매개변수에서 타입 정보가 사라지는 구조 등 이런 언어가 설계된 방식 쪽이 다시 정리된 게 핵심이었다. 결국, 오늘은 새로 배웠다기보다는
흩어져 있던 C의 메모리 모델을 다시 한 번 구조로 묶어본 날이었다.