🔸 set (집합)

기본 특징

• Red-Black Tree (레드-블랙 트리)로 구현
• 중복 불가 - 각 요소는 유일해야 함
• 자동 정렬 - 삽입 시 자동으로 정렬된 상태 유지
• Balanced BST 특성상 모든 연산이 O(log n) 보장

시간 복잡도

메모리 구조 (Red-Black Tree)

레드-블랙 트리 속성:
1. 모든 노드는 Red 또는 Black
2. 루트는 항상 Black
3. 모든 리프(NULL)는 Black
4. Red 노드의 자식은 모두 Black
5. 모든 경로의 Black 노드 개수는 동일

예시: {10, 20, 30, 40, 50}
         30(B)
        /     \
     20(B)    40(B)
      /         \
   10(R)       50(R)

Stack:
┌──────────────────┐
│ root (pointer)  │ → 루트 노드
│ size            │ → 요소 개수
└──────────────────┘

Heap (각 노드):
┌────────────────────┐
│ color (R/B)       │
│ data              │
│ left (pointer)    │
│ right (pointer)   │
│ parent (pointer)  │
└────────────────────┘

사용 예시

#include <set>
#include <iostream>

std::set<int> s;

// ✅ 삽입 - O(log n)
s.insert(30);
s.insert(10);
s.insert(20);
s.insert(10);  // 중복 - 삽입 안 됨!

// ✅ 자동 정렬됨
for (int val : s) {
    std::cout << val << " ";  // 10 20 30
}

// ✅ 검색 - O(log n)
auto it = s.find(20);
if (it != s.end()) {
    std::cout << "Found: " << *it;
}

// ✅ 삭제 - O(log n)
s.erase(20);

// ✅ 범위 기반 검색
auto lower = s.lower_bound(15);  // >= 15인 첫 요소
auto upper = s.upper_bound(25);  // > 25인 첫 요소

커스텀 비교 함수

// 내림차순 정렬
std::set<int, std::greater<int>> descSet;

// 커스텀 비교자
struct Person {
    std::string name;
    int age;
};

struct CompareByAge {
    bool operator()(const Person& a, const Person& b) const {
        return a.age < b.age;
    }
};

std::set<Person, CompareByAge> people;

🔸 multiset (중복 허용 집합)

기본 특징

• set과 동일하게 Red-Black Tree로 구현
• 중복 허용 - 동일한 값을 여러 번 삽입 가능
• 자동 정렬 유지
• 시간 복잡도는 set과 동일

set vs multiset

std::set<int> s;
s.insert(10);
s.insert(10);
s.insert(10);
std::cout << s.size();  // 1 (중복 무시)

std::multiset<int> ms;
ms.insert(10);
ms.insert(10);
ms.insert(10);
std::cout << ms.size();  // 3 (중복 허용)

중복 요소 처리

std::multiset<int> ms = {10, 20, 20, 30, 30, 30};

// ✅ 특정 값의 개수 세기 - O(log n + k), k는 중복 개수
int count = ms.count(30);  // 3

// ✅ 특정 값의 범위 찾기
auto range = ms.equal_range(30);
for (auto it = range.first; it != range.second; ++it) {
    std::cout << *it << " ";  // 30 30 30
}

// ✅ 특정 값 하나만 삭제
auto it = ms.find(30);
if (it != ms.end()) {
    ms.erase(it);  // 30 하나만 삭제
}

// ✅ 특정 값 모두 삭제
ms.erase(30);  // 30 모두 삭제

🔸 map (키-값 쌍)

기본 특징

• Red-Black Tree로 구현
• 키(Key)는 중복 불가, 값(Value)은 중복 가능
• 키 기준으로 자동 정렬
• set과 동일한 시간 복잡도

시간 복잡도

메모리 구조

Heap (각 노드):
┌────────────────────┐
│ color (R/B)       │
│ pair<Key, Value>  │ ← key와 value를 함께 저장
│ left (pointer)    │
│ right (pointer)   │
│ parent (pointer)  │
└────────────────────┘

사용 예시

#include <map>
#include <string>

std::map<std::string, int> ages;

// ✅ 삽입 방법 1: operator[] - O(log n)
ages["Alice"] = 25;
ages["Bob"] = 30;

// ✅ 삽입 방법 2: insert - O(log n)
ages.insert({"Charlie", 35});
ages.insert(std::make_pair("David", 40));

// ✅ 검색 - O(log n)
auto it = ages.find("Alice");
if (it != ages.end()) {
    std::cout << it->first << ": " << it->second;  // Alice: 25
}

// ⚠️ operator[]의 주의점
int age = ages["Eve"];  // 키가 없으면 자동 생성! (value는 0으로 초기화)
std::cout << ages.size();  // 5 (Eve가 추가됨)

// ✅ 안전한 검색: at() 사용
try {
    int age = ages.at("Frank");  // 키가 없으면 예외 발생
} catch (const std::out_of_range& e) {
    std::cout << "Key not found!";
}

iterator 활용

std::map<std::string, int> scores = {
    {"Alice", 90},
    {"Bob", 85},
    {"Charlie", 95}
};

// ✅ 순회 (키 기준 정렬된 순서)
for (const auto& [name, score] : scores) {
    std::cout << name << ": " << score << "\n";
}
// Alice: 90
// Bob: 85
// Charlie: 95

🔸 multimap (중복 키 허용)

기본 특징

• map과 동일하게 Red-Black Tree로 구현
• 키 중복 허용
• operator[] 사용 불가 (어떤 값을 반환할지 모호)

사용 예시

std::multimap<std::string, int> scores;

scores.insert({"Alice", 90});
scores.insert({"Alice", 85});  // 같은 키에 다른 값
scores.insert({"Bob", 95});

// ✅ 특정 키의 모든 값 찾기
auto range = scores.equal_range("Alice");
for (auto it = range.first; it != range.second; ++it) {
    std::cout << it->second << " ";  // 85 90 (정렬됨)
}

🔸 unordered_set (해시 집합)

기본 특징

• Hash Table로 구현
• 중복 불가
• 정렬되지 않음 (순서 보장 안 됨)
• 평균 O(1), 최악 O(n) 시간 복잡도

시간 복잡도

메모리 구조 (Hash Table with Separate Chaining)

Hash Table 구조:

해시 함수: hash(value) % bucket_count

Bucket Array (vector):
┌─────┬─────┬─────┬─────┬─────┐
│  0 │  1  │  2  │  3  │  4  │
└──┬──┴──┬──┴──┬──┴──┬──┴──┬──┘
   │     │     │     │     │
   ↓     ↓     ↓     ↓     ↓
  [10]  [21]  NULL [13]  [24]
   ↓     ↓           ↓     ↓
  [30]  NULL        [33]  NULL

각 버킷은 Linked List로 구현 (Separate Chaining)
해시 충돌 발생 시 같은 버킷에 연결

Stack:
┌──────────────────┐
│ buckets (array) │ → 버킷 배열
│ size            │ → 요소 개수
│ bucket_count    │ → 버킷 개수
│ max_load_factor │ → 최대 로드 팩터 (기본 1.0)
└──────────────────┘

해시 함수와 충돌 처리

// 해시 값 계산 예시
hash<int> hashFunc;
size_t hashValue = hashFunc(42);

// 버킷 인덱스 = hash(value) % bucket_count
size_t bucketIndex = hashValue % bucket_count;

// ✅ Separate Chaining
// 같은 버킷에 여러 요소가 linked list로 연결됨

Load Factor와 Rehashing

std::unordered_set<int> us;

// Load Factor = size / bucket_count
// 기본 max_load_factor = 1.0

us.insert(10);
us.insert(20);
us.insert(30);

std::cout << "Size: " << us.size() << "\n";
std::cout << "Bucket count: " << us.bucket_count() << "\n";
std::cout << "Load factor: " << us.load_factor() << "\n";
std::cout << "Max load factor: " << us.max_load_factor() << "\n";

// ⚠️ load_factor > max_load_factor 되면 Rehashing 발생!
// Rehashing: O(n) - 모든 요소를 새 버킷에 재배치

Rehashing 최적화

std::unordered_set<int> us;

// ✅ 미리 버킷 예약 - rehashing 방지
us.reserve(1000);  // 최소 1000개 요소를 담을 수 있도록 버킷 확보

// ✅ max_load_factor 조정
us.max_load_factor(0.5);  // 로드 팩터를 낮춰서 충돌 감소 (메모리 trade-off)

사용 예시

#include <unordered_set>

std::unordered_set<int> us;

// ✅ 삽입 - 평균 O(1)
us.insert(10);
us.insert(20);
us.insert(30);

// ✅ 검색 - 평균 O(1)
if (us.find(20) != us.end()) {
    std::cout << "Found!";
}

// ⚠️ 순서 보장 안 됨!
for (int val : us) {
    std::cout << val << " ";  // 순서 예측 불가
}

커스텀 타입을 위한 Hash Function 정의

방법 1: Hash Function Object 생성

struct Person {
    std::string name;
    int age;

    bool operator==(const Person& other) const {
        return name == other.name && age == other.age;
    }
};

// 커스텀 해시 함수 객체
struct PersonHash {
    size_t operator()(const Person& p) const {
        // 여러 필드를 조합한 해시 값 계산
        size_t h1 = std::hash<std::string>{}(p.name);
        size_t h2 = std::hash<int>{}(p.age);
        return h1 ^ (h2 << 1);  // XOR과 shift 조합
    }
};

// 사용
std::unordered_set<Person, PersonHash> people;
people.insert({"Alice", 25});

방법 2: std 네임스페이스에 특수화 주입

struct Person {
    std::string name;
    int age;

    bool operator==(const Person& other) const {
        return name == other.name && age == other.age;
    }
};

// std::hash 특수화
namespace std {
    template<>
    struct hash<Person> {
        size_t operator()(const Person& p) const {
            size_t h1 = hash<string>{}(p.name);
            size_t h2 = hash<int>{}(p.age);
            return h1 ^ (h2 << 1);
        }
    };
}

// 사용 (추가 템플릿 인자 불필요)
std::unordered_set<Person> people;
people.insert({"Alice", 25});

커스텀 Equality Operator

// 방법 1: 클래스 내부에 operator== 정의 (위 예시 참고)

// 방법 2: 별도의 함수 객체
struct PersonEqual {
    bool operator()(const Person& a, const Person& b) const {
        return a.name == b.name && a.age == b.age;
    }
};

std::unordered_set<Person, PersonHash, PersonEqual> people;

🔸 unordered_map (해시 맵)

기본 특징

• Hash Table로 구현
• 키 중복 불가
• unordered_set과 동일한 시간 복잡도
• 실무에서 가장 많이 사용됨
• 알고리즘 면접에서 자주 출제됨

시간 복잡도

메모리 구조

Bucket Array:
┌──────┬──────┬──────┬──────┐
│  0   │  1  │  2   │  3  │
└───┬──┴──┬───┴──┬───┴──┬───┘
   │     │      │      │
   ↓     ↓      ↓      ↓
 {k1:v1} NULL {k2:v2} NULL
   ↓                   ↓
 {k3:v3}             {k4:v4}

각 노드는 pair<Key, Value> 저장

사용 예시

#include <unordered_map>
#include <string>

std::unordered_map<std::string, int> phoneBook;

// ✅ 삽입 - 평균 O(1)
phoneBook["Alice"] = 1234;
phoneBook["Bob"] = 5678;
phoneBook.insert({"Charlie", 9012});

// ✅ 검색 - 평균 O(1)
auto it = phoneBook.find("Alice");
if (it != phoneBook.end()) {
    std::cout << it->first << ": " << it->second;
}

// ✅ operator[] - 평균 O(1)
int number = phoneBook["Alice"];  // 1234

// ⚠️ 키가 없으면 자동 생성
int unknown = phoneBook["David"];  // David 키 생성, value = 0

// ✅ 성능 최적화
phoneBook.reserve(10000);  // 예상 크기 미리 예약

실무 활용 예시

// 빈도수 카운팅
std::unordered_map<char, int> freq;
std::string text = "hello world";
for (char c : text) {
    freq[c]++;
}

// 캐싱 (Memoization)
std::unordered_map<int, int> cache;
int fibonacci(int n) {
    if (n <= 1) return n;
    if (cache.find(n) != cache.end()) {
        return cache[n];
    }
    cache[n] = fibonacci(n-1) + fibonacci(n-2);
    return cache[n];
}

// 그래프 인접 리스트
std::unordered_map<int, std::vector<int>> graph;
graph[1] = {2, 3};
graph[2] = {4};

커스텀 타입 예시

struct Point {
    int x, y;
    bool operator==(const Point& other) const {
        return x == other.x && y == other.y;
    }
};

struct PointHash {
    size_t operator()(const Point& p) const {
        return std::hash<int>{}(p.x) ^ (std::hash<int>{}(p.y) << 1);
    }
};

std::unordered_map<Point, std::string, PointHash> locations;
locations[{0, 0}] = "Origin";
locations[{10, 20}] = "Point A";

🔸 unordered_multiset / unordered_multimap

기본 특징

• 각각 unordered_set, unordered_map의 중복 허용 버전
• 시간 복잡도 동일
• unordered_multimap은 operator[] 사용 불가

사용 예시

std::unordered_multiset<int> ums = {10, 20, 20, 30, 30, 30};

// 특정 값의 개수
int count = ums.count(30);  // 3

// 특정 값 모두 찾기
auto range = ums.equal_range(30);
for (auto it = range.first; it != range.second; ++it) {
    std::cout << *it << " ";
}

🔸 set vs unordered_set 비교

성능 비교

선택 가이드

// ✅ set을 사용해야 하는 경우:
// 1. 정렬된 순서가 필요할 때
std::set<int> sorted = {30, 10, 20};
for (int val : sorted) {
    std::cout << val << " ";  // 10 20 30 (정렬됨)
}

// 2. 범위 검색이 필요할 때
auto lower = sorted.lower_bound(15);
auto upper = sorted.upper_bound(25);

// 3. 최악의 경우에도 일정한 성능이 필요할 때 (O(log n) 보장)

// ✅ unordered_set을 사용해야 하는 경우:
// 1. 빠른 검색이 최우선일 때 (평균 O(1))
std::unordered_set<int> fast;

// 2. 순서가 중요하지 않을 때

// 3. 데이터 크기를 미리 알고 reserve 가능할 때
fast.reserve(10000);

map vs unordered_map 비교

🔸 Hash Function 설계 원칙

좋은 해시 함수의 조건

1. 결정론적 (Deterministic): 같은 입력은 항상 같은 해시 값
2. 균등 분포 (Uniform Distribution): 해시 값이 고르게 분포
3. 효율성 (Efficient): 계산이 빠름 (O(1))
4. 충돌 최소화: 서로 다른 입력에 대해 다른 해시 값

해시 조합 기법

// ❌ 나쁜 예: 단순 더하기 (충돌 많음)
size_t badHash = hash<int>{}(x) + hash<int>{}(y);

// ✅ 좋은 예 1: XOR + Shift
size_t goodHash1 = hash<int>{}(x) ^ (hash<int>{}(y) << 1);

// ✅ 좋은 예 2: Boost 스타일
size_t goodHash2 = hash<int>{}(x);
goodHash2 ^= hash<int>{}(y) + 0x9e3779b9 + (goodHash2 << 6) + (goodHash2 >> 2);

// ✅ 좋은 예 3: 여러 필드 조합
struct Data {
    int a, b, c;
};

size_t hash_value(const Data& d) {
    size_t seed = 0;
    seed ^= hash<int>{}(d.a) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    seed ^= hash<int>{}(d.b) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    seed ^= hash<int>{}(d.c) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    return seed;
}

🔸 핵심 정리

컨테이너 선택 가이드

순서가 필요한가?
├─ YES → set / map
│         - 정렬된 순서 보장
│         - 범위 검색 가능
│         - O(log n) 성능 보장
│
└─ NO → unordered_set / unordered_map
          - 평균 O(1) 성능
          - 메모리 사용량 높음
          - rehashing 주의

중복이 필요한가?
├─ YES → multiset / multimap / unordered_multiset / unordered_multimap
└─ NO → set / map / unordered_set / unordered_map

키-값 쌍이 필요한가?
├─ YES → map / unordered_map
└─ NO → set / unordered_set

성능 최적화 팁

1. unordered_* 사용 시:

   • 예상 크기를 아는 경우 reserve() 사용
   • max_load_factor 조정으로 충돌 제어
   • 좋은 해시 함수 설계

2. set/map 사용 시:

   • 커스텀 비교 함수로 정렬 순서 제어
   • lower_bound, upper_bound 활용

3. 일반적인 권장사항:

   • 대부분의 경우: unordered_map (실무 표준)
   • 정렬이 필요한 경우: map
   • 중복이 필요한 경우: multiset / multimap

실무에서 자주 쓰이는 패턴

// 1. 빈도수 카운팅
unordered_map<string, int> wordCount;

// 2. 중복 제거
unordered_set<int> uniqueValues;

// 3. 캐싱/메모이제이션
unordered_map<int, Result> cache;

// 4. 그래프 표현
unordered_map<Node, vector<Node>> adjacencyList;

// 5. 빠른 조회 테이블
unordered_map<string, UserData> userDatabase;

<참고 자료>

코드없는 프로그래밍 std::set std::map std::unordered_set std::unordered_map Red-Black Tree Hash Table

🔸 list (이중 연결 리스트)

기본 특징

• Doubly-Linked List로 구현
• 각 노드는 이전/다음 노드를 가리키는 두 개의 포인터 보유
• Insertion/Deletion: O(1) (위치를 알고 있을 때)
• Random Access: O(n) (순차 탐색 필요)

메모리 구조

Stack:
┌──────────────────┐
│ first (pointer) │ → 첫 번째 노드
│ last (pointer)  │ → 마지막 노드
│ size            │ → 요소 개수
└──────────────────┘

Heap:
┌────┬────┬────┐    ┌────┬────┬────┐    ┌────┬────┬────┐
│prev│data│next│ ↔ │prev│data│next│ ↔ │prev│data│next│
└────┴────┴────┘    └────┴────┴────┘    └────┴────┴────┘

• 스택에는 first 포인터, last 포인터, size 정보 저장
• 실제 데이터는 힙(Heap)에 동적 할당

정렬

std::list<int> myList = {3, 1, 4, 1, 5};

// ✅ list 전용 sort() 멤버 함수 사용 (O(n log n))
myList.sort();  

// ❌ std::sort() 사용 불가 (Random Access Iterator 필요)
// std::sort(myList.begin(), myList.end());  // 컴파일 에러!

주요 연산 시간 복잡도

🔸 forward_list (단일 연결 리스트)

기본 특징

• Singly-Linked List로 구현
• 각 노드는 다음 노드만 가리킴 (이전 노드 포인터 없음)
• list보다 메모리 효율적 (포인터 하나만 필요)
• Random Access: O(n)

메모리 구조

Stack:
┌──────────────────┐
│ front (pointer) │ → 첫 번째 노드
└──────────────────┘

Heap:
┌────┬────┐    ┌────┬────┐    ┌────┬────┐
│data│next│ → │data│next│ → │data│next│ → nullptr
└────┴────┘    └────┴────┘    └────┴────┘

• 스택에는 front 포인터 하나만 저장
• last 포인터나 size 정보는 저장하지 않음 (메모리 절약)

제한 사항

std::forward_list<int> fList = {1, 2, 3, 4, 5};

// ✅ 가능한 연산
fList.push_front(0);
fList.pop_front();
fList.insert_after(fList.begin(), 10);

// ❌ 불가능한 연산
// fList.push_back(6);   // back 포인터 없음
// fList.size();         // size 저장 안 함 (O(n)으로 계산 가능)
// fList[2];             // Random Access 불가

🔸 vector vs list vs forward_list

성능 비교

실제 find() 성능

// 둘 다 O(n)이지만 실제로는 vector가 훨씬 빠름!
std::vector<int> vec(1000000);
std::list<int> lst(1000000);

// vector의 find: 메모리가 연속적 → 캐시 히트율 높음 ✅
auto it1 = std::find(vec.begin(), vec.end(), 999999);

// list의 find: 메모리가 분산 → 캐시 미스 많음 ❌
auto it2 = std::find(lst.begin(), lst.end(), 999999);

왜 vector가 더 빠를까? (캐시 지역성)

• CPU는 메모리에서 데이터를 가져올 때 캐시 라인 단위로 가져옴
• vector: 메모리가 연속 → 한 번에 여러 요소를 캐시에 로드 ✅
• list: 메모리가 분산 → 각 노드마다 캐시 미스 발생 ❌

병렬 프로그래밍에서의 문제

// ❌ list는 병렬화가 어려움
// 각 노드가 분산되어 있어서 동시 접근 시 동기화 오버헤드 큼
std::list<int> lst;

// ✅ vector는 병렬화가 용이함
// 메모리가 연속적이라 분할하기 쉬움
std::vector<int> vec;
#pragma omp parallel for
for (int i = 0; i < vec.size(); i++) {
    // 병렬 처리
}

선택 가이드

• 대부분의 경우: vector 사용 ✅
• 중간 삽입/삭제가 빈번: list 고려
• 메모리 최소화 + 단방향만 필요: forward_list

🔸 stack (스택)

기본 특징

• LIFO (Last In First Out) 구조
• Container Adapter (다른 컨테이너를 감싸서 구현)
• 기본 컨테이너: deque (변경 가능)

지원 컨테이너

// ✅ 기본 (deque)
std::stack<int> s1;

// ✅ vector로 구현
std::stack<int, std::vector<int>> s2;

// ✅ list로 구현
std::stack<int, std::list<int>> s3;

// ❌ forward_list는 불가 (back 접근 필요)
// std::stack<int, std::forward_list<int>> s4;  // 컴파일 에러!

주요 연산

std::stack<int> s;

s.push(10);     // O(1) - 삽입
s.pop();        // O(1) - 제거 (값 반환 안 함!)
int top = s.top();  // O(1) - 최상단 접근
bool empty = s.empty();  // O(1)
size_t sz = s.size();    // O(1)

성능 최적화가 필요한 경우

// 직접 구현 예시 (vector 기반)
template<typename T>
class FastStack {
private:
    std::vector<T> data;
public:
    void push(const T& value) {
        data.push_back(value);
    }
    void pop() {
        data.pop_back();
    }
    T& top() {
        return data.back();
    }
    // ...
};

🔸 queue (큐)

기본 특징

• FIFO (First In First Out) 구조
• Container Adapter
• 기본 컨테이너: deque (변경 가능)

지원 컨테이너

// ✅ 기본 (deque)
std::queue<int> q1;

// ✅ list로 구현
std::queue<int, std::list<int>> q2;

// ❌ vector는 불가 (front에서 pop이 O(n))
// std::queue<int, std::vector<int>> q3;  // 컴파일 에러!

// ❌ forward_list는 불가 (back 접근 필요)
// std::queue<int, std::forward_list<int>> q4;  // 컴파일 에러!

주요 연산

std::queue<int> q;

q.push(10);     // O(1) - 뒤에 삽입
q.pop();        // O(1) - 앞에서 제거
int front = q.front();  // O(1) - 앞 요소 접근
int back = q.back();    // O(1) - 뒤 요소 접근
bool empty = q.empty(); // O(1)
size_t sz = q.size();   // O(1)

🔸 priority_queue (우선순위 큐)

기본 특징

• Max Heap으로 구현 (기본값)
• 가장 큰 원소가 항상 top에 위치
• Container Adapter (기본: vector)

시간 복잡도

힙 구조 (배열 기반)

인덱스:  0   1   2   3   4   5   6
값:    [100, 50, 80, 30, 20, 60, 70]

트리 구조:
           100 (idx=0)
          /   \
        50     80
       /  \   /  \
      30  20 60  70

부모-자식 관계:
- 부모 노드: (idx - 1) / 2
- 왼쪽 자식: 2 * idx + 1
- 오른쪽 자식: 2 * idx + 2

힙 속성

• Max Heap: 부모 노드 ≥ 자식 노드
• Min Heap: 부모 노드 ≤ 자식 노드

사용 예시

#include <queue>

// ✅ Max Heap (기본)
std::priority_queue<int> maxHeap;
maxHeap.push(30);
maxHeap.push(100);
maxHeap.push(50);
std::cout << maxHeap.top();  // 100

// ✅ Min Heap (greater 사용)
std::priority_queue<int, std::vector<int>, std::greater<int>> minHeap;
minHeap.push(30);
minHeap.push(100);
minHeap.push(50);
std::cout << minHeap.top();  // 30

// ✅ 커스텀 비교 함수
auto cmp = [](int a, int b) { return a > b; };  // Min Heap
std::priority_queue<int, std::vector<int>, decltype(cmp)> customHeap(cmp);

인덱스 계산 예시

// 인덱스 3의 부모: (3 - 1) / 2 = 1
// 인덱스 1의 왼쪽 자식: 2 * 1 + 1 = 3
// 인덱스 1의 오른쪽 자식: 2 * 1 + 2 = 4

🔸 heap 알고리즘 (Algorithm Library)

기본 특징

• <algorithm> 헤더에 포함된 힙 관련 함수들
• 기존 컨테이너(주로 vector)를 힙으로 변환/관리
• priority_queue와 동일한 내부 구조

주요 함수

사용 예시

#include <algorithm>
#include <vector>

std::vector<int> vec = {30, 100, 50, 20, 80};

// ✅ 힙 생성 - O(n)
std::make_heap(vec.begin(), vec.end());
// vec: [100, 80, 50, 20, 30] (Max Heap)

// ✅ 최대값 확인
std::cout << vec.front();  // 100 (O(1))

// ✅ 최대값 제거
std::pop_heap(vec.begin(), vec.end());  // O(log n)
// 최대값을 맨 뒤로 이동
// vec: [80, 30, 50, 20, 100]
vec.pop_back();  // 실제 제거 - O(1)
// vec: [80, 30, 50, 20]

// ✅ 새 요소 추가
vec.push_back(90);  // O(1)
std::push_heap(vec.begin(), vec.end());  // O(log n)
// vec: [90, 80, 50, 20, 30]

make_heap이 O(n)인 이유

Naive 방식 (위에서 아래로): O(n log n)
- 각 요소를 하나씩 삽입: n번
- 각 삽입마다 heapify: O(log n)
- 총 시간: O(n log n)

Floyd 알고리즘 (아래에서 위로): O(n) ✅
- 리프 노드는 이미 힙 속성 만족
- 아래에서 위로 올라가며 heapify
- 높이 h인 노드 개수: n / 2^(h+1)
- 각 노드의 작업량: O(h)
- 총 시간: Σ(n / 2^(h+1) * h) = O(n)

priority_queue vs heap 알고리즘

// priority_queue: 편리하지만 유연성 낮음
std::priority_queue<int> pq;
pq.push(10);
// 내부 데이터 직접 접근 불가

// heap 알고리즘: 유연하지만 수동 관리 필요
std::vector<int> vec = {10, 20, 30};
std::make_heap(vec.begin(), vec.end());
// 벡터에 직접 접근 가능 ✅
vec[0];  // 최대값 확인

언제 heap 알고리즘을 사용할까?

• 기존 컨테이너를 힙으로 변환해야 할 때
• 힙 내부 데이터에 직접 접근이 필요할 때
• 부분 정렬이 필요할 때 (Top K 문제 등)

🔸 핵심 정리

컨테이너 선택 가이드

1. 대부분의 경우: vector 사용 (캐시 효율, 랜덤 액세스)
2. 중간 삽입/삭제 빈번: list 고려
3. 메모리 최소화: forward_list
4. LIFO 필요: stack
5. FIFO 필요: queue
6. 우선순위 관리: priority_queue
7. 힙 직접 제어: heap 알고리즘

성능 최적화 팁

• 대부분의 경우 vector가 가장 빠름 (캐시 지역성)
• 병렬 프로그래밍에서는 vector 사용 권장
• 성능이 매우 중요하면 직접 구현 고려
• 힙 생성은 make_heap이 삽입보다 빠름 (O(n) vs O(n log n))

<참고 자료>

코드없는 프로그래밍 C++ Standard Containers std::list std::forward_list std::priority_queue Heap Algorithms Container Adapters

🔸 C-Style 문자열의 메모리 위치

char 배열 vs char 포인터

int main()
{
    char a[] = "hello";      // 스택에 할당
    char* b = "hello";       // 포인터는 스택, 문자열은 read-only 영역

    // 수정 테스트
    a[0] = 'd';              // ✅ 성공: "dello"
    // b[0] = 'd';           // ❌ Segmentation Fault!

    return 0;
}

메모리 레이아웃

스택 (Stack):
┌──────────────┐
│ a[] 배열     │
│ 'h''e''l''l' │
│ 'o' '\0'     │
└──────────────┘
  ↑ 수정 가능

스택 (Stack):
┌──────────────┐
│ b (포인터)   │
│ 0x400000 ────┼───→ Read-Only Data Segment:
└──────────────┘     ┌──────────────────┐
                    │ "hello\0"       │
                    └──────────────────┘
                      ↑ 수정 불가능!

문자열 리터럴은 read-only data segment에 저장되며, 수정 시도 시 segmentation fault 발생

const char*에는 반드시 const 사용

// ❌ 나쁜 코드: 경고 발생 (C++11 이후 deprecated)
char* b = "hello";
b[0] = 'd';  // Undefined Behavior (대부분 Segmentation Fault)

// ✅ 좋은 코드: const로 명시
const char* b = "hello";  // 수정 불가능함을 명시
// b[0] = 'd';  // 컴파일 에러로 실수 방지!

🔸 std::string의 메모리 할당

Small String Optimization (SSO)

std::string은 항상 힙에 할당되는 것이 아니라, SSO를 통해 짧은 문자열은 스택에, 긴 문자열만 힙에 저장

#include <string>

int main()
{
    // 짧은 문자열 (SSO 적용, 보통 15-22자 이하)
    std::string short_str = "hello";
    // → 스택에 저장 (힙 할당 없음)

    // 긴 문자열 (SSO 한계 초과)
    std::string long_str = "This is a very long string that exceeds SSO";
    // → 힙에 동적 할당

    return 0;
}

SSO 동작 방식

std::string 객체 (스택):
┌────────────────────────┐
│ 포인터 / 데이터        │ ← SSO 버퍼 (15-22자)
│ 길이                  │
│ 용량 / SSO 플래그      │
└────────────────────────┘

짧은 문자열 ("hello"):
┌─────────────────────────┐
│ "hello\0"... (여유공간)│ ← 스택 내부에 직접 저장
│ 길이: 5                │
│ 플래그: SSO 사용 중     │
└─────────────────────────┘

긴 문자열:
┌───────────────┐
│ 포인터 ───────┼───→ 힙 메모리
│ 길이: 50     │    "This is a very long..."
│ 용량: 64     │
└───────────────┘

구현에 따라 GCC/MSVC는 15자, Clang은 22자까지 SSO 적용

🔸 std::string_view (C++17)

std::string_view란?

• std::span과 비슷한 개념
• 포인터 + 길이 정보만 저장 (16 bytes)
• 소유권 없이 문자열을 참조만 함

메모리 구조

template<typename CharT>
class basic_string_view
{
    const CharT* ptr;   // 데이터 시작 주소 (8 bytes)
    size_t length;      // 문자열 길이 (8 bytes)
};

// sizeof(std::string_view) == 16 bytes

🔸 함수 파라미터로 문자열 전달하기

const std::string& 사용 시 문제

void print(const std::string& str)
{
    std::cout << str << std::endl;
}

int main()
{
    const char* c_str = "hello";

    // ❌ 비효율: 임시 std::string 객체 생성!
    print(c_str);

    // 실제 동작:
    // 1. 임시 std::string tmp(c_str) 생성
    // 2. 힙 메모리 할당 (SSO 초과 시)
    // 3. "hello" 복사
    // 4. print(tmp) 호출
    // 5. tmp 소멸, 메모리 해제

    return 0;
}

const char*나 문자열 리터럴을 const std::string& 파라미터로 전달하면 임시 std::string 객체가 생성되어 메모리 할당과 복사 발생

std::string_view 사용

void print(std::string_view str)  // ✅ 효율적!
{
    std::cout << str << std::endl;
}

int main()
{
    // 모두 임시 객체 생성 없이 전달 가능

    // C 문자열 배열
    char arr[] = "hello";
    print(arr);  // 포인터 + 길이만 전달

    // const char* 포인터
    const char* c_str = "world";
    print(c_str);  // 포인터 + 길이만 전달

    // std::string
    std::string cpp_str = "string";
    print(cpp_str);  // string의 내부 포인터 + 길이만 전달

    return 0;
}

string_view는 포인터와 길이만 저장하므로 임시 객체 생성이나 메모리 할당 없이 전달 가능

성능 차이

// const std::string& 사용
void old_print(const std::string& str) { }

old_print("hello");
// → 임시 std::string 생성
// → 힙 할당 (SSO 초과 시)
// → 메모리 복사
// → 함수 호출
// → 소멸 및 메모리 해제

// std::string_view 사용
void new_print(std::string_view str) { }

new_print("hello");
// → 포인터와 길이만 전달 (16 bytes 복사)
// → 끝!

벤치마크 결과 string_view 사용 시 문자열 리터럴 전달에서 100배 이상 성능 향상 가능

🔸 std::string_view 주의사항

Dangling Reference

std::string_view get_view()
{
    std::string temp = "temporary";
    return std::string_view(temp);  // ❌ 위험!
}  // temp 소멸

int main()
{
    auto view = get_view();
    std::cout << view << std::endl;  // ❌ Undefined Behavior

    return 0;
}

std::string 재할당 시 무효화

std::string str = "short";
std::string_view view = str;

std::cout << view << std::endl;  // ✅ "short"

str = "This is a very long string that causes reallocation";
// → str의 내부 버퍼가 재할당됨

std::cout << view << std::endl;  // ❌ Undefined Behavior
                                 // view는 여전히 옛날 주소를 가리킴

임시 객체 바인딩

void process(std::string_view view)
{
    // view 사용...
}

int main()
{
    std::string get_string() { return "temp"; }

    // ❌ 위험: 임시 객체의 view
    process(get_string());  // get_string() 반환 후 즉시 소멸

    // ✅ 안전: 수명 연장
    std::string str = get_string();
    process(str);

    return 0;
}

string_view는 임시 객체도 받아들이므로, 수명 관리에 주의 필요

🔸 char[], const char*, std::string 비교

🔸 함수 파라미터 선택 가이드

// 읽기 전용, 다양한 타입 받기
void read_only(std::string_view str)  // ✅ 권장 (C++17 이상)
{
    std::cout << str << std::endl;
}

// std::string만 받기
void string_only(const std::string& str)
{
    std::cout << str.size() << std::endl;
}

// 소유권 획득
void take_ownership(std::string str)  // 복사 또는 이동
{
    // str을 멤버 변수에 저장하거나 수정
}

// 수정이 필요한 경우
void modify(std::string& str)
{
    str += " modified";
}

// C 라이브러리와 호환 필요
void c_compat(const char* str)
{
    printf("%s\n", str);  // C 함수 사용
}

🔸 핵심 정리

char 배열 vs char 포인터

• char a[] = "hello": 스택에 복사본 생성, 수정 가능
• const char* b = "hello": read-only 영역 참조, 수정 불가 (const 필수)

std::string의 메모리

• 짧은 문자열 (15-22자): 스택 (SSO)
• 긴 문자열: 힙 동적 할당
• 자동 메모리 관리 (RAII)

std::string_view

• 포인터 + 길이만 저장 (16 bytes)
• const char*, std::string 모두 임시 객체 없이 전달
• 읽기 전용, 소유권 없음
• 주의: 원본 수명 관리 필요

함수 파라미터 권장사항 (C++17 이상)

• 읽기 전용: std::string_view
• 수정 필요: std::string&
• 소유권 획득: std::string (값 전달)

<참고 자료>

코드없는 프로그래밍 C++ std::string Implementation C++ std::string_view

🔸 배열과 컨테이너 비교

5가지 메모리 관리 방법 비교

#include <array>
#include <vector>

int main()
{
    // 1. C 정적 배열
    int cArray[5] = {1, 2, 3, 4, 5};  
    // 스택, 컴파일 타임 크기, 자동 관리

    // 2. C++ 동적 배열 (new/delete)
    int* cppDynArray = new int[5]{1, 2, 3, 4, 5};
    // 힙, 런타임 크기, 수동 할당/해제
    // ✅ 타입 안전
    // ❌ 메모리 누수 위험
    delete[] cppDynArray;

    // 3. std::array
    std::array<int, 5> stdArray{1, 2, 3, 4, 5};  
    // 스택, 컴파일 타임 크기, 자동 관리
    // ✅ 타입 안전, 크기 정보 유지

    // 4. std::vector (권장!)
    std::vector<int> vec{1, 2, 3, 4, 5};  
    // 힙, 런타임 크기, 자동 관리
    // ✅ 동적 크기 조정
    // ✅ 메모리 자동 해제
    // ✅ 타입 안전

    return 0;
}

메모리 할당 위치 정리

왜 std::vector를 사용해야 하는가?

// ❌ C++ 동적 배열의 문제점
int* arr2 = new int[5];
// delete[] 깜빡하면 메모리 누수
// 크기 변경 불가
delete[] arr2;

// ✅ std::vector의 장점
std::vector<int> vec(5);
// 자동 메모리 관리
// 크기 정보 포함 (vec.size())
// 동적 크기 조정 (vec.push_back())
// 타입 안전
// RAII (자동 소멸)

🔸 std::array

std::array란?

• 컴파일 타임에 크기가 고정된 배열
• 스택 메모리에 할당
• C 스타일 배열을 안전하게 감싼 래퍼

std::array의 장점

std::array<int, 5> arr{1, 2, 3, 4, 5};

// 경계 검사
arr.at(10);  // std::out_of_range 예외 발생

// 크기 확인
std::cout << arr.size() << std::endl;  // 5

// 반복자 사용
for (auto it = arr.begin(); it != arr.end(); ++it)
{
    std::cout << *it << " ";
}

// Range-based for
for (const auto& elem : arr)
{
    std::cout << elem << " ";
}

std::array vs C 배열

// C 배열
int cArr[5];
// sizeof(cArr) == 20 (5 * 4)
// 함수에 전달 시 포인터로 decay
// 크기 정보 손실

void func(int arr[])  // 실제로는 int*
{
    // sizeof(arr) == 8 (포인터 크기)
}

// std::array
std::array<int, 5> stdArr;
// sizeof(stdArr) == 20 (5 * 4)
// 함수에 전달 시 크기 정보 유지

void func(std::array<int, 5>& arr)
{
    // sizeof(arr) == 20
    // arr.size() == 5
}

🔸 다차원 배열과 벡터

메모리 레이아웃 차이

1. 다차원 배열 (스택, 연속된 메모리)

int arr[3][4] = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// 메모리 레이아웃 (연속적):
// [1][2][3][4][5][6][7][8][9][10][11][12]
//  ↑ 스택에 한 번에 할당

2. 다차원 벡터 (힙, 분산된 메모리)

std::vector<std::vector<int>> vec = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// 메모리 레이아웃 (비연속적):
// vec (스택):
// [ptr1][ptr2][ptr3]
//   ↓     ↓     ↓
// 힙:
// [1][2][3][4]  (첫 번째 행)
// [5][6][7][8]  (두 번째 행)
// [9][10][11][12]  (세 번째 행)

연속된 메모리를 사용하는 Wrapper

벡터를 사용하되 연속된 메모리를 유지하려면 1차원 벡터로 관리하고 인덱스 변환을 사용:

class Matrix
{
public:
    Matrix(size_t rows, size_t cols)
        : mRows{rows}, mCols{cols}, mData(rows * cols)
    {
    }

    int& operator()(size_t row, size_t col)
    {
        return mData[row * mCols + col];  // 2D → 1D 인덱스 변환
    }

    const int& operator()(size_t row, size_t col) const
    {
        return mData[row * mCols + col];
    }

private:
    size_t mRows;
    size_t mCols;
    std::vector<int> mData;  // 1차원 벡터로 연속 메모리 보장
};

int main()
{
    Matrix mat(3, 4);

    // 사용
    mat(0, 0) = 1;
    mat(0, 1) = 2;
    mat(1, 0) = 5;

    return 0;
}

🔸 캐시 최적화 (Cache Hit/Miss)

캐시 라인 (Cache Line)

• CPU 캐시의 최소 단위 (보통 64 bytes)
• 메모리를 읽을 때 캐시 라인 단위로 가져옴
• 연속된 메모리는 캐시에 함께 로드됨

잘못된 루프 (Cache Miss 많음)

const size_t ROWS = 1000;
const size_t COLS = 1000;
int arr[ROWS][COLS];

// ❌ 열 우선 순회 (Column-major)
for (size_t col = 0; col < COLS; col++)
{
    for (size_t row = 0; row < ROWS; row++)
    {
        arr[row][col] = 0;  // 메모리 점프 발생!
    }
}

메모리 접근 패턴:

arr[0][0] → arr[1][0] → arr[2][0] → ...
               ↓         ↓ (COLS * 4 bytes 떨어짐)
            캐시 미스!

올바른 루프 (Cache Hit 많음)

// ✅ 행 우선 순회 (Row-major)
for (size_t row = 0; row < ROWS; row++)
{
    for (size_t col = 0; col < COLS; col++)
    {
        arr[row][col] = 0;  // 연속된 메모리 접근!
    }
}

메모리 접근 패턴:

arr[0][0] → arr[0][1] → arr[0][2] → ...
                ↓         ↓ (4 bytes 떨어짐, 같은 캐시 라인)
             캐시 히트!

핵심 규칙: Inner Loop는 Cache Line에 맞춰라

• C/C++ 배열은 row-major 순서로 저장됨
• Inner loop에서 연속된 메모리를 접근하도록 설계
• 열(column) 순회를 inner loop에 배치

🔸 std::deque (Double-Ended Queue)

std::deque란?

• 양쪽 끝에서 삽입/삭제가 O(1)인 컨테이너
• 실무에서는 거의 사용하지 않음
• Vector와 List의 중간 형태

std::deque vs std::vector

#include <deque>
#include <vector>

std::vector<int> vec;
vec.push_back(1);   // 뒤에 추가: O(1) (amortized)
// vec.push_front(0);  // ❌ vector는 push_front 없음

std::deque<int> deq;
deq.push_back(1);   // 뒤에 추가: O(1)
deq.push_front(0);  // ✅ 앞에 추가: O(1)

deque의 메모리 구조 (Chunk Array)

Deque:
┌─────────────────────┐
│ Chunk 포인터들      │ (중앙 배열)
│ [ptr1][ptr2][ptr3] │
└────┬─────┬─────┬────┘
     ↓     ↓     ↓
   청크   청크   청크 (힙)
[▢▢▢▢][■■■■][▢▢▢▢]
           ↑
         데이터

Vector의 재할당 vs Deque의 확장

Vector:

std::vector<int> vec{1, 2, 3, 4};
// 메모리: [1][2][3][4] (capacity: 4)

vec.push_back(5);  // capacity 부족!
// → 새 공간 할당 (capacity: 8)
// → 기존 데이터 전체 복사/이동
// → 기존 공간 해제

Deque:

std::deque<int> deq{1, 2, 3, 4};
// Chunk1: [1][2][3][4]

deq.push_back(5);  // 현재 청크가 가득 찬 경우
// → 새 청크만 할당
// → 기존 데이터는 그대로!
// Chunk1: [1][2][3][4]
// Chunk2: [5][▢][▢][▢]

Deque의 장점

1. push_front() / push_back() 모두 O(1)
2. 재할당 시 기존 데이터를 복사/이동하지 않음
3. Iterator invalidation이 적음 (중간 삽입 제외)

Deque의 단점

1. 두 번의 포인터 역참조 필요

   deq[i];
   // 1. 어느 청크인지 계산
   // 2. 청크 포인터 배열에서 청크 주소 읽기
   // 3. 청크 내에서 오프셋 계산
   // 4. 실제 데이터 접근

2. 캐시 미스 가능성

   • 청크들이 메모리상 분산되어 있음
   • 연속된 접근 시 캐시 효율 떨어짐

3. 메모리 오버헤드

   • 청크 포인터 배열 관리
   • 각 청크마다 약간의 낭비 공간

성능 비교

// 랜덤 접근
vec[1000];   // O(1), 빠름 (한 번의 역참조)
deq[1000];   // O(1), 느림 (두 번의 역참조)

// 앞쪽 삽입
// vec.push_front()  // 없음 (구현하려면 O(n))
deq.push_front(x);   // O(1)

// 뒤쪽 삽입
vec.push_back(x);    // O(1) amortized
deq.push_back(x);    // O(1)

언제 Deque를 사용할까?

• 양쪽 끝에서 삽입/삭제가 빈번할 때
• 중간 접근은 드물 때
• 하지만 대부분의 경우 std::vector가 더 나음

🔸 push_back vs emplace_back

기본 차이

struct Student {
    std::string name;
    int age;
    Student(std::string n, int a) : name(n), age(a) {
        std::cout << "생성자 호출\n";
    }
    Student(const Student& other) : name(other.name), age(other.age) {
        std::cout << "복사 생성자 호출\n";
    }
    Student(Student&& other) : name(std::move(other.name)), age(other.age) {
        std::cout << "이동 생성자 호출\n";
    }
};

std::vector<Student> v;

// push_back: 임시 객체 생성 → 이동 → 소멸
v.push_back(Student("Alice", 20));
// 출력: 생성자 호출 → 이동 생성자 호출

// emplace_back: 컨테이너 내부에서 직접 생성
v.emplace_back("Bob", 21);
// 출력: 생성자 호출 (끝)

언제 emplace_back이 확실히 유리한가?

1. 복사/이동이 비용이 큰 경우

struct BigData {
    std::vector<int> data;
    BigData(int size) : data(size, 42) {}
};

std::vector<BigData> v;

// push_back: 생성 → 이동 (vector 내부 데이터도 이동)
v.push_back(BigData(10000));

// emplace_back: 바로 생성 (이동 없음)
v.emplace_back(10000);  // ✅ 더 효율적

2. 복사 생성자가 delete된 경우

struct NonCopyable {
    NonCopyable(int x) {}
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable(NonCopyable&&) = delete;
};

std::vector<NonCopyable> v;

// v.push_back(NonCopyable(42));  // ❌ 컴파일 에러
v.emplace_back(42);               // ✅ 작동

3. 생성자 인자가 여러 개일 때 (코드 간결성)

struct Point3D {
    double x, y, z;
    Point3D(double x, double y, double z) : x(x), y(y), z(z) {}
};

std::vector<Point3D> points;

// push_back: 임시 객체 명시적 생성
points.push_back(Point3D(1.0, 2.0, 3.0));

// emplace_back: 인자만 전달 (더 간결)
points.emplace_back(1.0, 2.0, 3.0);

C++17 이후의 현실: Copy Elision

std::vector<Student> v;

// C++17 이후: 컴파일러가 임시 객체 생성을 최적화
v.push_back(Student("Alice", 20));
// → 실제로는 vector 내부에 바로 생성될 수 있음 (RVO)

v.emplace_back("Alice", 20);
// → 거의 동일한 코드로 컴파일됨

간단한 타입에서는 차이가 거의 없음:

std::vector<int> v;

v.push_back(42);     // 성능 차이 없음
v.emplace_back(42);  // 성능 차이 없음

주의사항: explicit 생성자

struct Widget {
    explicit Widget(int x) {}
};

std::vector<Widget> v;

// v.push_back(42);     // ❌ 컴파일 에러 (explicit 생성자)
v.emplace_back(42);     // ✅ 작동 (의도치 않은 변환 가능)

실전 가이드

// ✅ emplace_back 사용 권장
std::vector<ComplexType> v;
v.emplace_back(arg1, arg2, arg3);  // 생성자 인자 직접 전달

// ✅ push_back도 괜찮음 (C++17 이후)
std::vector<int> numbers;
numbers.push_back(42);  // 간단한 타입은 가독성 우선

// ✅ 이미 생성된 객체는 push_back
Student s("Alice", 20);
v.push_back(std::move(s));  // 명시적 의도

결론

• 복잡한 객체나 여러 인자: emplace_back 사용
• 간단한 타입이나 가독성 우선: push_back도 OK
• 현대 C++에서는 큰 차이 없는 경우 많음
• 일관성 있게 사용하는 것이 중요

🔸 std::span (C++20)

std::span이란?

• 연속된 메모리 공간을 참조하는 경량 뷰
• 소유권 없이 데이터를 참조만 함
• 배열, vector, array 등을 통일된 인터페이스로 다룸

기본 사용법

#include <span>

void print(std::span<int> data)  // 배열, vector, array 모두 받음
{
    for (int val : data)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;
}

int main()
{
    // C 배열
    int arr[] = {1, 2, 3, 4, 5};
    print(arr);

    // std::array
    std::array<int, 5> stdArr{1, 2, 3, 4, 5};
    print(stdArr);

    // std::vector
    std::vector<int> vec{1, 2, 3, 4, 5};
    print(vec);

    return 0;
}

std::span의 구조

template<typename T>
class span
{
    T* ptr;      // 데이터 시작 주소 (8 bytes)
    size_t size; // 원소 개수 (8 bytes)
};

// sizeof(std::span<int>) == 16 bytes

메모리 레이아웃

Vector:
┌──────────┐
│ vec      │ (스택)
│ ptr ─────┼───────→ [1][2][3][4][5] (힙)
│ size: 5  │
│ cap: 5   │
└──────────┘

Span:
┌──────────┐
│ span     │ (스택)
│ ptr ─────┼───────→ [1][2][3][4][5] (vec의 데이터를 참조)
│ size: 5  │
└──────────┘
  ↑ 소유권 없음!

주의사항: Dangling Span

std::span<int> createSpan()
{
    std::vector<int> vec{1, 2, 3, 4, 5};
    return std::span{vec};  // ❌ 위험!
}  // vec 소멸

int main()
{
    auto sp = createSpan();
    // sp는 이미 소멸된 vec의 메모리를 가리킴 (Dangling)
    std::cout << sp[0] << std::endl;  // ❌ Undefined Behavior

    return 0;
}

재할당 시 문제

std::vector<int> vec{1, 2, 3};
std::span<int> sp{vec};

std::cout << sp[0] << std::endl;  // ✅ 1

vec.push_back(4);
vec.push_back(5);  // capacity 부족 → 재할당!

// sp는 여전히 옛날 메모리를 가리킴
std::cout << sp[0] << std::endl;  // ❌ Undefined Behavior

안전한 사용법

void process(std::span<int> data)
{
    // data 사용
    for (int& val : data)
    {
        val *= 2;
    }
}  // span 소멸, 하지만 원본 데이터는 유지

int main()
{
    std::vector<int> vec{1, 2, 3, 4, 5};

    // ✅ 안전: process 내부에서만 사용
    process(vec);

    // vec는 여전히 유효
    for (int val : vec)
    {
        std::cout << val << " ";  // 2 4 6 8 10
    }

    return 0;
}

std::span의 장점

1. 통일된 인터페이스

   • 배열, vector, array를 동일하게 처리
   • 함수 오버로딩 불필요

2. 효율적

   • 복사 비용 없음 (16 bytes만)
   • 소유권 없이 참조만

3. 부분 뷰 생성

   std::vector<int> vec{1, 2, 3, 4, 5};
   
   std::span<int> all{vec};                    // 전체
   std::span<int> first3 = all.first(3);       // 처음 3개
   std::span<int> last2 = all.last(2);         // 마지막 2개
   std::span<int> middle = all.subspan(1, 3);  // 중간 3개

std::span vs const T&

// ❌ 배열은 받을 수 없음
void process(const std::vector<int>& data) { }

int arr[] = {1, 2, 3};
// process(arr);  // 컴파일 에러

// ✅ 배열도 받을 수 있음
void process(std::span<int> data) { }
process(arr);  // OK

🔸 핵심 정리

배열과 컨테이너 선택 가이드

• C 배열: 레거시 코드나 성능이 극도로 중요한 경우만
• C++ 동적 배열 (new/delete): ❌ 사용하지 말 것 (std::vector 사용 권장)
• std::array: 컴파일 타임 고정 크기, 스택 할당 필요시
• std::vector: 대부분의 경우 이것을 사용 (권장)

다차원 배열 vs 벡터

• 배열: 연속 메모리 (캐시 효율 좋음)
• 벡터: 분산 메모리 (유연함)
• Wrapper로 연속 메모리 유지 가능

캐시 최적화

• Inner loop는 연속된 메모리 접근
• Row-major 순서 (행 우선)
• 10배 이상 성능 차이 가능

std::deque

• 양쪽 끝 O(1) 삽입/삭제
• 재할당 시 복사 불필요
• 두 번의 포인터 역참조, 캐시 비효율
• 실무에서 거의 사용 안 함

push_back vs emplace_back

• 복잡한 객체: emplace_back 권장
• 간단한 타입: 둘 다 OK
• C++17 이후 성능 차이 줄어듦
• 일관성 있게 사용

std::span (C++20)

• 연속 메모리 참조 뷰
• 소유권 없음 (16 bytes)
• Dangling 주의
• 재할당 시 무효화

<참고 자료>

코드없는 프로그래밍 C++ std::array C++ std::deque C++ std::span

🔸 Vector란?

Vector의 특징

• 동적 크기 배열 (Dynamic Size Array)
• 시퀀스 컨테이너 (Sequence Container)
• 연속된 메모리 공간에 원소 저장
• C++에서 가장 많이 사용되는 컨테이너

Vector 객체의 메모리 구조

Vector 객체 (스택):
┌──────────────────────┐
│ 포인터 (8 bytes)    │ → 실제 데이터 (힙)
├──────────────────────┤
│ size (8 bytes)     │   현재 원소 개수
├──────────────────────┤
│ capacity (8 bytes) │  할당된 공간 크기
└──────────────────────┘

🔸 reserve와 메모리 재할당

메모리 재할당 문제

std::vector<int> vec;
vec.push_back(1);  // capacity: 1
vec.push_back(2);  // capacity: 2 (메모리 재할당!)
vec.push_back(3);  // capacity: 4 (메모리 재할당!)
vec.push_back(4);  // capacity: 4 (재할당 없음)
vec.push_back(5);  // capacity: 8 (메모리 재할당!)

재할당 과정:

1. 새로운 더 큰 공간 할당 (보통 2배)
2. 기존 원소들을 새 공간으로 복사/이동 (O(n))
3. 기존 공간 해제

문제점:

• 벡터 뒤에 다른 메모리가 할당되어 있으면 확장 불가
• 새 공간 할당 후 전체 복사/이동 발생
• 시간 복잡도: O(n)
• 성능 저하 발생

reserve로 해결

std::vector<int> vec;
vec.reserve(100);  // 미리 100개 공간 확보

for (int i = 0; i < 100; i++)
{
    vec.push_back(i);  // 재할당 없음!
}

reserve의 효과:

• 메모리 재할당 횟수 감소
• 불필요한 복사/이동 제거
• 성능 향상

🔸 noexcept와 Move 최적화

문제 상황

class Cat
{
public:
    explicit Cat(std::string name) : mName{std::move(name)}
    {
        std::cout << mName << " Cat constructor" << std::endl;
    }

    ~Cat()
    {
        std::cout << mName << " ~Cat()" << std::endl;
    }

    Cat(const Cat& other) : mName{other.mName}
    {
        std::cout << mName << " copy constructor" << std::endl;
    }

    Cat(Cat&& other) : mName{std::move(other.mName)}
    {
        std::cout << mName << " move constructor" << std::endl;
    }

private:
    std::string mName;
};

int main()
{
    std::vector<Cat> cats;
    cats.emplace_back("kitty");
    cats.emplace_back("nabi");

    return 0;
}

출력:

kitty Cat constructor
nabi Cat constructor
kitty copy constructor  ← ❌ Move가 아닌 Copy!
kitty ~Cat()
kitty ~Cat()
nabi ~Cat()

왜 Copy가 발생했을까?

메모리 재할당 과정:

1. kitty 추가 (capacity: 1)
2. nabi 추가 시도
3. capacity 부족 → 새 공간 할당 (capacity: 2)
4. kitty를 새 공간으로 이동
   → 하지만 Copy Constructor 호출됨!

컴파일러가 Copy를 선택하는 이유:

• Move Constructor에서 예외가 발생하면 원본 데이터가 손상될 수 있음
• Copy는 예외가 발생해도 원본이 안전함 (Strong Exception Guarantee)
• 안전을 위해 Move 대신 Copy 선택

해결 방법 1: noexcept 추가

class Cat
{
public:
    explicit Cat(std::string name) : mName{std::move(name)}
    {
        std::cout << mName << " Cat constructor" << std::endl;
    }

    ~Cat() noexcept
    {
        std::cout << mName << " ~Cat()" << std::endl;
    }

    Cat(const Cat& other) : mName{other.mName}
    {
        std::cout << mName << " copy constructor" << std::endl;
    }

    Cat(Cat&& other) noexcept  // ✅ noexcept 추가
        : mName{std::move(other.mName)}
    {
        std::cout << mName << " move constructor" << std::endl;
    }

    Cat& operator=(const Cat& other)
    {
        mName = other.mName;
        return *this;
    }

    Cat& operator=(Cat&& other) noexcept  // ✅ noexcept 추가
    {
        mName = std::move(other.mName);
        return *this;
    }

private:
    std::string mName;
};

int main()
{
    std::vector<Cat> cats;
    cats.emplace_back("kitty");
    cats.emplace_back("nabi");

    return 0;
}

출력 (noexcept 추가 후):

kitty Cat constructor
nabi Cat constructor
kitty move constructor  ← ✅ Move로 변경!
~Cat()                  ← 이동된 원본의 소멸자 (mName이 비어있음)
kitty ~Cat()            ← 새 위치의 kitty
nabi ~Cat()

해결 방법 2: reserve 사용

int main()
{
    std::vector<Cat> cats;
    cats.reserve(2);  // ✅ 미리 공간 확보

    cats.emplace_back("kitty");
    cats.emplace_back("nabi");
    // 재할당 없음 → Copy/Move 모두 발생하지 않음!

    return 0;
}

noexcept를 붙여야 하는 함수

1. Destructor (소멸자)
2. Move Constructor (이동 생성자)
3. Move Assignment (이동 대입 연산자)

이유:

• 위 함수들은 새로운 리소스를 요청하지 않음
• 메모리 할당 실패 등의 예외가 발생할 가능성이 없음
• noexcept를 명시하면 컴파일러가 최적화 가능

🔸 Vector for Loop의 함정

세 가지 반복문 방식

std::vector<int> nums{0, 1, 0, 1};

// 1. Index-based
for (std::size_t idx = 0; idx < nums.size(); idx++)
{
    if (nums[idx] == 0)
    {
        nums.emplace_back(2);
    }
}

// 2. Iterator-based
for (auto itr = nums.begin(); itr != nums.end(); itr++)
{
    if (*itr == 0)
    {
        nums.emplace_back(2);
    }
}

// 3. Range-based
for (auto& num : nums)
{
    if (num == 0)
    {
        nums.emplace_back(2);
    }
}

결과:

• Index-based: ✅ 정상 동작
• Iterator-based: ❌ 잘못된 결과 또는 무한 루프
• Range-based: ❌ 잘못된 결과 또는 크래시

Iterator-based의 문제

std::vector<int> nums{0, 1, 0, 1};  // capacity: 4

for (auto itr = nums.begin(); itr != nums.end(); itr++)
{
    if (*itr == 0)  // 첫 번째 0 발견
    {
        nums.emplace_back(2);  // capacity 부족 → 재할당!
        // ❌ 문제: 재할당으로 메모리 주소 변경
        //    itr은 여전히 옛날 주소를 가리킴 (dangling iterator)
        //    nums.end()는 새 주소를 가리킴
    }
}

Range-based의 문제

Range-based for는 내부적으로 iterator를 사용하므로 같은 문제 발생

// C++17: Range-based는 이렇게 변환됨
{
    auto&& __range = nums;
    auto __begin = __range.begin();
    auto __end = __range.end();
    for (; __begin != __end; ++__begin)
    {
        auto& num = *__begin;
        // capacity 변경 시 __begin과 __end가 invalidate됨
    }
}

Index-based는 왜 안전한가?

for (std::size_t idx = 0; idx < nums.size(); idx++)
{
    if (nums[idx] == 0)
    {
        nums.emplace_back(2);
        // nums.size()는 매번 새로 계산됨
        // nums[idx]는 매번 새 주소에서 접근
        // ✅ 재할당되어도 문제없음
    }
}

핵심 규칙

❗ For loop 내부에서 vector의 크기가 변경(증가)되면 반드시 index-based를 사용!

// ✅ 안전: Index-based
for (std::size_t i = 0; i < vec.size(); i++)
{
    vec.push_back(x);  // OK
}

// ❌ 위험: Iterator-based
for (auto it = vec.begin(); it != vec.end(); it++)
{
    vec.push_back(x);  // Undefined Behavior 가능!
}

// ❌ 위험: Range-based
for (auto& elem : vec)
{
    vec.push_back(x);  // Undefined Behavior 가능!
}

예외: reserve로 미리 공간 확보

std::vector<int> nums{0, 1, 0, 1};
nums.reserve(100);  // 충분한 공간 확보

// ✅ capacity 변경이 없으므로 iterator도 안전
for (auto it = nums.begin(); it != nums.end(); it++)
{
    if (*it == 0)
    {
        nums.emplace_back(2);  // 재할당 없음 → 안전
    }
}

🔸 erase vs remove (erase-remove idiom)

erase의 비효율성

std::vector<int> nums{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 짝수 제거 (비효율적인 방법)
for (auto it = nums.begin(); it != nums.end();)
{
    if (*it % 2 == 0)
    {
        it = nums.erase(it);  // ❌ 매번 뒤의 원소들을 이동
    }
    else
    {
        ++it;
    }
}

erase의 동작:

[1, 2, 3, 4, 5]에서 2 제거:

1. 2 제거
2. 뒤의 모든 원소를 앞으로 이동
   [1, _, 3, 4, 5]
   [1, 3, _, 4, 5]
   [1, 3, 4, _, 5]
   [1, 3, 4, 5, _]
3. size 감소

→ 한 번 제거할 때마다 O(n)
→ k개 제거 시 O(n*k)

remove의 효율적인 동작

std::vector<int> nums{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// std::remove는 제거할 원소를 뒤로 모음
auto new_end = std::remove_if(nums.begin(), nums.end(), 
    [](int n) { return n % 2 == 0; }
);

// 실제 제거는 erase로
nums.erase(new_end, nums.end());

remove의 two-pointer 알고리즘:

초기: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
       ↑
     write (복사할 위치)
       ↑
     read (확인할 위치)

1. read=1 (홀수) → write 위치에 복사, 둘 다 전진
   [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
       ↑
     write
       ↑
     read

2. read=2 (짝수) → 복사 안 함, read만 전진
   [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
       ↑
     write
          ↑
         read

3. read=3 (홀수) → write에 복사, 둘 다 전진
   [1, 3, 3, 4, 5, 6, 7, 8, 9, 10]
          ↑
        write
             ↑
           read

4. 반복...

최종: [1, 3, 5, 7, 9, 6, 7, 8, 9, 10]
                     ↑
                   new_end (반환값)

→ new_end부터 end()까지 erase
→ 총 O(n) 한 번만!

erase-remove idiom (표준 패턴)

// ✅ 효율적인 방법
nums.erase(
    std::remove_if(nums.begin(), nums.end(), 
        [](int n) { return n % 2 == 0; }
    ),
    nums.end()
);

// 한 줄로 표현 가능

성능 비교:

• erase 반복: O(n*k) - k는 제거할 원소 개수
• erase-remove idiom: O(n) - 단 한 번의 순회

C++20: std::erase_if

// C++20부터는 더 간단
std::erase_if(nums, [](int n) { return n % 2 == 0; });

🔸 Vector 알고리즘

정렬 알고리즘

std::sort (일반 정렬)

#include <algorithm>

std::vector<int> nums{5, 2, 8, 1, 9, 3};

std::sort(nums.begin(), nums.end());
// nums: {1, 2, 3, 5, 8, 9}

// 내림차순
std::sort(nums.begin(), nums.end(), std::greater<int>{});
// nums: {9, 8, 5, 3, 2, 1}

// 커스텀 비교
std::sort(nums.begin(), nums.end(), [](int a, int b) {
    return std::abs(a) < std::abs(b);  // 절댓값 기준
});

시간 복잡도: O(n log n)

std::stable_sort (안정 정렬)

struct Person
{
    std::string name;
    int age;
};

std::vector<Person> people{
    {"Alice", 25},
    {"Bob", 30},
    {"Charlie", 25},
    {"David", 30}
};

// 나이 기준 정렬
std::stable_sort(people.begin(), people.end(), 
    [](const Person& a, const Person& b) {
        return a.age < b.age;
    }
);

// stable_sort: 나이가 같으면 원래 순서 유지
// Alice(25), Charlie(25), Bob(30), David(30)

// sort: 나이가 같으면 순서 보장 안 됨
// Charlie(25), Alice(25), David(30), Bob(30) 가능

stable_sort의 특징:

• 동일한 값의 원소들의 상대적 순서 유지
• 시간 복잡도: O(n log n) (merge sort 기반으로 추측)
• sort보다 약간 느리지만 안정성 보장

std::partial_sort (부분 정렬)

std::vector<int> nums{5, 2, 8, 1, 9, 3, 7, 4, 6};

// 처음 3개만 정렬
std::partial_sort(nums.begin(), nums.begin() + 3, nums.end());
// nums: {1, 2, 3, ?, ?, ?, ?, ?, ?}
//        ↑정렬됨  ↑정렬 안 됨 (순서 불확정)

// 실제: {1, 2, 3, 8, 9, 5, 7, 4, 6}

사용 사례:

• Top K 문제 (상위 K개만 필요)
• 전체 정렬보다 빠름
• 시간 복잡도: O(n log k) - k는 부분 정렬할 개수

std::nth_element

std::vector<int> nums{5, 2, 8, 1, 9, 3, 7, 4, 6};

// 중앙값 찾기 (5번째로 작은 원소)
std::nth_element(nums.begin(), nums.begin() + 4, nums.end());
// nums[4]는 정확히 5번째로 작은 원소
// nums[4] 왼쪽은 모두 작거나 같음
// nums[4] 오른쪽은 모두 크거나 같음
// 하지만 양쪽이 정렬된 것은 아님

std::cout << nums[4] << std::endl;  // 5 (중앙값)

특징:

• n번째 원소만 정확한 위치에 배치
• 양쪽은 정렬되지 않음
• 시간 복잡도: O(n) (평균)
• 중앙값, 백분위수 찾기에 유용

최솟값/최댓값 찾기

std::vector<int> nums{5, 2, 8, 1, 9, 3};

// 최솟값
auto min_it = std::min_element(nums.begin(), nums.end());
std::cout << *min_it << std::endl;  // 1

// 최댓값
auto max_it = std::max_element(nums.begin(), nums.end());
std::cout << *max_it << std::endl;  // 9

// 최솟값과 최댓값 동시에
auto [min_it2, max_it2] = std::minmax_element(nums.begin(), nums.end());
std::cout << *min_it2 << ", " << *max_it2 << std::endl;  // 1, 9

// 인덱스 찾기
auto min_idx = std::distance(nums.begin(), min_it);
std::cout << "Min index: " << min_idx << std::endl;  // 3

std::distance

• Iterator 간의 거리 계산
• 인덱스를 구할 때 유용

  auto it = std::find(nums.begin(), nums.end(), 8);
  if (it != nums.end())
  {
    std::size_t index = std::distance(nums.begin(), it);
    std::cout << "Found at index: " << index << std::endl;
  }

합계 및 누적 연산

std::accumulate

#include <numeric>

std::vector<int> nums{1, 2, 3, 4, 5};

// 합계
int sum = std::accumulate(nums.begin(), nums.end(), 0);
std::cout << sum << std::endl;  // 15

// 곱셈
int product = std::accumulate(nums.begin(), nums.end(), 1,
    [](int acc, int n) { return acc * n; }
);
std::cout << product << std::endl;  // 120

// 문자열 연결
std::vector<std::string> words{"Hello", " ", "World"};
std::string result = std::accumulate(words.begin(), words.end(), 
    std::string{},
    [](std::string acc, const std::string& s) { return acc + s; }
);
std::cout << result << std::endl;  // "Hello World"

std::reduce (C++17)

// std::accumulate와 비슷하지만 병렬 실행 가능
int sum = std::reduce(std::execution::par,  // 병렬 실행
    nums.begin(), nums.end(), 0
);

차이점:

• accumulate: 순차 실행, 순서 보장
• reduce: 병렬 실행 가능, 순서 보장 안 됨 (결합 법칙 필요)

🔸 핵심 정리

Vector 메모리 관리

• Vector 객체: 24 bytes (포인터 + size + capacity)
• reserve()로 재할당 방지
• noexcept로 move 최적화

반복문 주의사항

• Loop 내부에서 크기 변경 시 반드시 index-based 사용
• Iterator와 Range-based는 재할당 시 dangling

효율적인 삭제

• erase 반복: O(n*k)
• erase-remove idiom: O(n)
• C++20: std::erase_if

알고리즘 선택

• 전체 정렬: std::sort O(n log n)
• 안정 정렬: std::stable_sort O(n log n)
• 부분 정렬: std::partial_sort O(n log k)
• n번째 원소: std::nth_element O(n)
• 최솟값/최댓값: std::min_element / std::max_element O(n)

<참고 자료>

코드없는 프로그래밍 C++ std::vector C++ Algorithms Library

🔸 Functional Programming (함수형 프로그래밍)

함수형 프로그래밍이란?

• 함수를 일급 객체(First-class citizen)로 취급
• 함수를 변수에 저장하고, 인자로 전달하고, 반환 가능
• 불변성(Immutability)과 순수 함수(Pure Function) 강조

JavaScript 예제

function plus(a) {
    let localVar = a;
    return function(x) {
        return localVar + x;
    }
}

let plus3 = plus(3);
let plus5 = plus(5);

console.log(plus3(10));  // 13
console.log(plus5(10));  // 15

핵심 개념:

• plus 함수는 다른 함수를 반환
• 반환된 함수는 localVar를 "기억"함 (클로저)
• plus3과 plus5는 각각 다른 상태를 가진 함수

🔸 C++에서 함수 객체로 구현

Functor (함수 객체) 사용

class Plus
{
public:
    explicit Plus(int a) : localVar{a} {}

    int operator()(int x) const  // () 연산자 오버로딩
    {
        return localVar + x;
    }

private:
    int localVar;  // 상태를 저장
};

int main()
{
    Plus plus3{3};  // localVar = 3인 함수 객체
    Plus plus5{5};  // localVar = 5인 함수 객체

    std::cout << plus3(10) << std::endl;  // 13
    std::cout << plus5(10) << std::endl;  // 15

    return 0;
}

동작 원리:

• operator()를 오버로딩하여 객체를 함수처럼 호출 가능
• 멤버 변수로 상태를 저장 (JavaScript의 클로저와 유사)
• plus3(10) → plus3.operator()(10) 호출

Functor의 장점:

• 상태를 가질 수 있음
• 인라인 최적화 가능
• 타입 안전성

🔸 Lambda Expression (람다 표현식)

람다 문법

[capture](parameters) -> return_type { body }

위 Functor를 람다로 변환

int main()
{
    auto lambdaPlus3 = [localVar = 3](int x)
    {
        return localVar + x;
    };

    std::cout << lambdaPlus3(10) << std::endl;  // 13

    // 또는 직접 호출
    std::cout << [](int x) { return 3 + x; }(10) << std::endl;  // 13

    return 0;
}

람다 vs Functor: 어셈블리 코드 동일

// Functor
Plus plus3{3};
plus3(10);

// Lambda
auto plus3 = [localVar = 3](int x) { return localVar + x; };
plus3(10);

// 둘 다 컴파일 후 동일한 어셈블리 코드 생성!
// 람다는 컴파일러가 자동으로 Functor 클래스를 생성

메모리 구조 비교

Functor의 메모리 구조:

Plus 객체 (sizeof: 4 bytes):
┌──────────────┐
│ localVar: 3 │  (4 bytes)
└──────────────┘
+ operator() 멤버 함수 코드 (코드 영역)

Lambda의 메모리 구조:

람다 객체 (sizeof: 4 bytes):
┌──────────────┐
│ localVar: 3 │  (4 bytes, 캡처된 값)
└──────────────┘
+ 컴파일러가 생성한 operator() 코드 (코드 영역)

람다의 장점:

• 간결한 문법
• 즉석에서 함수 정의 가능
• 코드 가독성 향상

🔸 Capture (캡처)

캡처 방식

1. Capture by Value (값 복사)

int main()
{
    int a = 10;
    int b = 20;

    // [=]: 모든 외부 변수를 값으로 캡처
    auto lambda1 = [=]() {
        std::cout << a << ", " << b << std::endl;  // 10, 20
    };

    // [a, b]: 특정 변수만 값으로 캡처
    auto lambda2 = [a, b]() {
        std::cout << a + b << std::endl;  // 30
    };

    // [a]: a만 값으로 캡처
    auto lambda3 = [a]() {
        std::cout << a << std::endl;  // 10
        // std::cout << b;  // ❌ 컴파일 에러! b는 캡처하지 않음
    };

    a = 100;  // 외부 변수 변경
    lambda1();  // 여전히 10, 20 출력 (복사본이므로)

    return 0;
}

2. Capture by Reference (참조)

int main()
{
    int a = 10;
    int b = 20;

    // [&]: 모든 외부 변수를 참조로 캡처
    auto lambda1 = [&]() {
        std::cout << a << ", " << b << std::endl;
        a = 100;  // ✅ 외부 변수 수정 가능
    };

    // [&a, &b]: 특정 변수만 참조로 캡처
    auto lambda2 = [&a, &b]() {
        a += b;  // 외부 a를 직접 수정
    };

    lambda1();  // 10, 20
    std::cout << a << std::endl;  // 100 (수정됨)

    lambda2();
    std::cout << a << std::endl;  // 120

    return 0;
}

3. 혼합 캡처

int main()
{
    int a = 10;
    int b = 20;

    // a는 값으로, b는 참조로
    auto lambda = [a, &b]() {
        // a = 100;  // ❌ 에러! a는 const (값 캡처)
        b = 100;     // ✅ OK (참조 캡처)
        std::cout << a << ", " << b << std::endl;
    };

    lambda();
    std::cout << b << std::endl;  // 100 (수정됨)

    return 0;
}

4. Init Capture (C++14)

int main()
{
    // 새로운 변수를 람다 내부에서 생성
    auto lambda = [value = 42, str = std::string("hello")]() {
        std::cout << value << ", " << str << std::endl;
    };

    lambda();  // 42, hello

    // Move capture
    std::unique_ptr<int> ptr = std::make_unique<int>(100);
    auto lambda2 = [p = std::move(ptr)]() {
        std::cout << *p << std::endl;
    };
    // ptr은 이제 nullptr

    return 0;
}

🔸 Capture by Reference 주의사항

Dangling Reference 문제

std::function<void()> createLambda()
{
    int localVar = 10;

    // ❌ 위험! localVar은 함수가 끝나면 소멸
    return [&localVar]() {
        std::cout << localVar << std::endl;  // Dangling reference!
    };
}

int main()
{
    auto lambda = createLambda();
    lambda();  // ❌ Undefined Behavior! localVar은 이미 소멸됨

    return 0;
}

해결 방법: Capture by Value

std::function<void()> createLambda()
{
    int localVar = 10;

    // ✅ 안전: 값으로 캡처
    return [localVar]() {
        std::cout << localVar << std::endl;
    };
}

int main()
{
    auto lambda = createLambda();
    lambda();  // ✅ 10 출력

    return 0;
}

힙 메모리의 경우도 주의

void dangerousCode()
{
    auto ptr = std::make_shared<int>(42);

    auto lambda = [&ptr]() {  // ❌ 참조 캡처
        std::cout << *ptr << std::endl;
    };

    // ptr이 여기서 소멸되면 lambda는 dangling reference를 가짐
}

캡처 선택 가이드

• 작은 객체 (int, double 등): 값 캡처
• 큰 객체: 참조 캡처 (수명 관리 주의!)
• 수정이 필요한 경우: 참조 캡처
• 람다를 반환하는 경우: 반드시 값 캡처
• 스마트 포인터: move capture 고려

🔸 Lambda This Capture (클래스 내부)

클래스 멤버 접근

class Counter
{
public:
    Counter() : count{0} {}

    void increment()
    {
        // [this]: 클래스의 this 포인터 캡처
        auto lambda = [this]() {
            count++;  // 멤버 변수 접근 가능
            std::cout << "Count: " << count << std::endl;
        };

        lambda();
    }

    void incrementMultiple(int times)
    {
        // 멤버 함수도 호출 가능
        auto lambda = [this](int n) {
            for (int i = 0; i < n; i++)
            {
                this->count++;  // 명시적으로 this-> 사용 가능
            }
            display();  // 멤버 함수 호출
        };

        lambda(times);
    }

    void display() const
    {
        std::cout << "Final count: " << count << std::endl;
    }

private:
    int count;
};

int main()
{
    Counter counter;
    counter.increment();          // Count: 1
    counter.incrementMultiple(5); // Final count: 6

    return 0;
}

C++17: [*this] (Copy Capture)

class MyClass
{
public:
    // 람다를 반환하는 경우: [*this] 필수!
    std::function<void()> createCallback()
    {
        // ❌ [this]: 위험! 객체가 소멸되면 dangling pointer
        // return [this]() {
        //     std::cout << data << std::endl;
        // };

        // ✅ [*this]: 안전! 객체 전체를 복사 (C++17)
        return [*this]() {
            std::cout << data << std::endl;  // 복사본 사용
        };
    }

    // 람다가 함수 내부에서만 사용되는 경우: [this] OK
    void processData()
    {
        std::vector<int> numbers{1, 2, 3};

        // ✅ [this]: 안전! 람다가 함수 밖으로 나가지 않음
        std::for_each(numbers.begin(), numbers.end(), [this](int n) {
            data += n;
        });
    }

private:
    int data{42};
};

int main()
{
    std::function<void()> callback;

    {
        MyClass obj;
        callback = obj.createCallback();  // 객체 복사됨

    }  // obj 소멸

    callback();  // ✅ 안전! 복사본 사용

    return 0;
}

🔸 Higher-Order Functions (고차 함수)

고차 함수란?

• 함수를 인자로 받거나 함수를 반환하는 함수
• C++ STL에서 많이 사용

std::for_each

#include <algorithm>
#include <vector>

int main()
{
    std::vector<int> numbers{1, 2, 3, 4, 5};

    // 람다를 인자로 전달
    std::for_each(numbers.begin(), numbers.end(), [](int n) {
        std::cout << n << " ";
    });
    std::cout << std::endl;  // 1 2 3 4 5

    // 각 원소를 제곱
    std::for_each(numbers.begin(), numbers.end(), [](int& n) {
        n = n * n;
    });
    // numbers는 이제 {1, 4, 9, 16, 25}

    return 0;
}

std::remove_if + erase

int main()
{
    std::vector<int> numbers{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 짝수 제거
    numbers.erase(
        std::remove_if(numbers.begin(), numbers.end(), [](int n) {
            return n % 2 == 0;  // 짝수면 true
        }),
        numbers.end()
    );

    // numbers는 이제 {1, 3, 5, 7, 9}
    for (int n : numbers)
    {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    return 0;
}

std::sort

int main()
{
    std::vector<int> numbers{5, 2, 8, 1, 9, 3};

    // 내림차순 정렬
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a > b;  // a가 b보다 크면 a를 앞에
    });

    // numbers는 이제 {9, 8, 5, 3, 2, 1}

    // 절댓값 기준 오름차순
    std::vector<int> nums{-5, 2, -8, 1, -3};
    std::sort(nums.begin(), nums.end(), [](int a, int b) {
        return std::abs(a) < std::abs(b);
    });
    // nums는 이제 {1, 2, -3, -5, -8}

    return 0;
}

std::transform

int main()
{
    std::vector<int> numbers{1, 2, 3, 4, 5};
    std::vector<int> squared(numbers.size());

    // 각 원소를 제곱하여 새 벡터에 저장
    std::transform(numbers.begin(), numbers.end(), squared.begin(), 
        [](int n) {
            return n * n;
        }
    );

    // squared는 {1, 4, 9, 16, 25}

    return 0;
}

std::accumulate (std::reduce)

#include <numeric>

int main()
{
    std::vector<int> numbers{1, 2, 3, 4, 5};

    // 합계
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0,
        [](int acc, int n) {
            return acc + n;
        }
    );
    std::cout << "Sum: " << sum << std::endl;  // 15

    // 곱셈
    int product = std::accumulate(numbers.begin(), numbers.end(), 1,
        [](int acc, int n) {
            return acc * n;
        }
    );
    std::cout << "Product: " << product << std::endl;  // 120

    return 0;
}

std::count_if

int main()
{
    std::vector<int> numbers{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 짝수 개수 세기
    int evenCount = std::count_if(numbers.begin(), numbers.end(), 
        [](int n) {
            return n % 2 == 0;
        }
    );

    std::cout << "Even count: " << evenCount << std::endl;  // 5

    return 0;
}

🔸 std::function (함수 래퍼)

std::function이란?

• 호출 가능한 모든 객체를 저장할 수 있는 범용 함수 래퍼
• 일반 함수, 람다, 함수 객체, 멤버 함수 포인터 등 저장 가능

기본 사용법

#include <functional>

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

int main()
{
    // 함수 포인터 저장
    std::function<int(int, int)> func1 = add;
    std::cout << func1(1, 2) << std::endl;  // 3

    // 람다 저장
    std::function<int(int, int)> func2 = [](int a, int b) {
        return a * b;
    };
    std::cout << func2(3, 4) << std::endl;  // 12

    // 함수 객체 저장
    std::function<int(int, int)> func3 = std::plus<int>{};
    std::cout << func3(5, 6) << std::endl;  // 11

    return 0;
}

함수를 매개변수로 전달

void execute(const std::function<void(int)>& fn, int value)
{
    std::cout << "Executing function with " << value << std::endl;
    fn(value);
}

int main()
{
    // 람다 전달
    execute([](int x) {
        std::cout << "Result: " << x * 2 << std::endl;
    }, 10);

    // 출력:
    // Executing function with 10
    // Result: 20

    return 0;
}

함수 컬렉션

int main()
{
    std::vector<std::function<void(int)>> operations;

    // 여러 함수를 벡터에 저장
    operations.push_back([](int x) { 
        std::cout << "Double: " << x * 2 << std::endl; 
    });
    operations.push_back([](int x) { 
        std::cout << "Square: " << x * x << std::endl; 
    });
    operations.push_back([](int x) { 
        std::cout << "Cube: " << x * x * x << std::endl; 
    });

    // 모든 함수 실행
    for (const auto& op : operations)
    {
        op(5);
    }

    // 출력:
    // Double: 10
    // Square: 25
    // Cube: 125

    return 0;
}

콜백 시스템 구현

class EventSystem
{
public:
    using Callback = std::function<void(const std::string&)>;

    void registerCallback(Callback cb)
    {
        callbacks.push_back(cb);
    }

    void trigger(const std::string& event)
    {
        std::cout << "Event triggered: " << event << std::endl;
        for (const auto& cb : callbacks)
        {
            cb(event);
        }
    }

private:
    std::vector<Callback> callbacks;
};

int main()
{
    EventSystem system;

    // 여러 콜백 등록
    system.registerCallback([](const std::string& event) {
        std::cout << "  Logger: " << event << std::endl;
    });

    system.registerCallback([](const std::string& event) {
        std::cout << "  Handler: Processing " << event << std::endl;
    });

    system.trigger("UserLogin");

    // 출력:
    // Event triggered: UserLogin
    //   Logger: UserLogin
    //   Handler: Processing UserLogin

    return 0;
}

std::function vs auto

// auto: 컴파일 타임에 타입 결정, 더 빠름
auto lambda1 = [](int x) { return x * 2; };

// std::function: 런타임 다형성, 오버헤드 있음
std::function<int(int)> lambda2 = [](int x) { return x * 2; };

// auto는 타입이 다르면 저장 불가
std::vector<auto> funcs;  // ❌ 컴파일 에러!

// std::function은 시그니처가 같으면 저장 가능
std::vector<std::function<int(int)>> funcs;  // ✅ OK

🔸 함수형 프로그래밍의 장점

Side Effect가 없음

// ❌ Side Effect 있음 (OOP 스타일)
class Counter
{
    int count = 0;
public:
    void increment() { count++; }  // 상태 변경
    int getCount() const { return count; }
};

// ✅ Side Effect 없음 (Functional 스타일)
int increment(int count) { return count + 1; }  // 새 값 반환, 원본 불변

int main()
{
    int count = 0;
    count = increment(count);  // 명시적 재할당
    count = increment(count);
    std::cout << count << std::endl;  // 2

    return 0;
}

순수 함수 (Pure Function)

• 같은 입력에 항상 같은 출력
• 외부 상태를 변경하지 않음
• 예측 가능하고 테스트하기 쉬움

// ✅ 순수 함수
int add(int a, int b)
{
    return a + b;  // 항상 같은 결과
}

// ❌ 순수하지 않은 함수
int globalCounter = 0;
int incrementGlobal()
{
    return ++globalCounter;  // 외부 상태 변경
}

불변성 (Immutability)

// Functional 스타일: 원본을 변경하지 않고 새로운 값 생성
std::vector<int> doubleValues(const std::vector<int>& numbers)
{
    std::vector<int> result;
    std::transform(numbers.begin(), numbers.end(), 
        std::back_inserter(result),
        [](int n) { return n * 2; }
    );
    return result;  // 새 벡터 반환
}

int main()
{
    std::vector<int> original{1, 2, 3, 4, 5};
    std::vector<int> doubled = doubleValues(original);

    // original은 그대로 {1, 2, 3, 4, 5}
    // doubled는 {2, 4, 6, 8, 10}

    return 0;
}

🔸 OOP vs Functional Programming

OOP가 적합한 경우

• 상태를 관리해야 하는 경우 (게임 캐릭터, GUI 컴포넌트)
• 객체 간의 복잡한 관계 (상속, 다형성)
• 대규모 시스템 설계

// OOP 예제: 게임 캐릭터
class Character
{
    int health;
    int level;
    std::string name;

public:
    void takeDamage(int damage) { health -= damage; }
    void levelUp() { level++; health = 100; }
    bool isAlive() const { return health > 0; }
};

Functional Programming이 적합한 경우

• 데이터 변환 파이프라인
• 병렬 처리 (Side Effect 없어서 안전)
• 수학적 계산

// Functional 예제: 데이터 처리
auto result = numbers
    | std::views::filter([](int n) { return n % 2 == 0; })
    | std::views::transform([](int n) { return n * n; })
    | std::views::take(5);

두 패러다임 함께 사용

class DataProcessor  // OOP: 클래스 구조
{
public:
    std::vector<int> process(const std::vector<int>& data)
    {
        // Functional: 순수 함수 체인
        std::vector<int> result;
        std::copy_if(data.begin(), data.end(), 
            std::back_inserter(result),
            [](int n) { return n > 0; }  // 양수만 필터
        );

        std::transform(result.begin(), result.end(), result.begin(),
            [](int n) { return n * 2; }  // 2배
        );

        return result;
    }
};

🔸 핵심 정리

람다 표현식

• 함수 객체의 간결한 표현
• 컴파일러가 자동으로 클래스 생성
• Functor와 동일한 성능

캡처 방식

• 값 캡처: 작은 객체, 람다를 반환할 때
• 참조 캡처: 큰 객체, 수정이 필요할 때 (수명 주의!)
• this 캡처: 멤버 접근 필요할 때
• [*this]: 객체 복사 (C++17, 안전)

STL 알고리즘

• std::for_each, std::transform, std::remove_if
• std::sort, std::accumulate, std::count_if
• 람다와 함께 사용하여 간결한 코드 작성

std::function

• 호출 가능한 모든 객체를 저장
• 함수를 인자로 전달하거나 컬렉션에 저장
• 오버헤드 있음 (auto가 더 빠름)

함수형 프로그래밍 장점

• Side Effect 없음
• 순수 함수로 예측 가능
• 병렬 처리에 유리
• 테스트하기 쉬움

패러다임 선택

• OOP: 상태 관리, 복잡한 시스템
• Functional: 데이터 변환, 병렬 처리
• 실전에서는 두 패러다임을 적절히 혼합

<참고 자료>

코드없는 프로그래밍 C++ Lambda Expressions C++ std::function

🔸 템플릿이란?

템플릿의 개념

• 변수의 타입을 미리 정하지 않고, 컴파일 타임에 타입을 지정하는 기능
• 코드 재사용성을 높이고 타입 안전성을 보장
• 제네릭 프로그래밍(Generic Programming)의 핵심

템플릿의 동작 원리

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

int main()
{
    int x = add(1, 2);        // int 버전 생성
    double y = add(1.5, 2.5); // double 버전 생성

    return 0;
}

• 템플릿 코드는 컴파일 전까지는 실제 코드로 존재하지 않음
• 템플릿이 사용될 때 해당 타입에 맞는 함수가 자동 생성됨 (Instantiation)

🔸 Function Template (함수 템플릿)

Function Overloading vs Template

❌ Function Overloading (비효율적)

int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }
float add(float a, float b) { return a + b; }
long add(long a, long b) { return a + b; }
// 타입마다 함수를 일일이 작성해야 함!

✅ Function Template (효율적)

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

// 컴파일러가 필요한 버전을 자동 생성
add(1, 2);        // int 버전
add(1.5, 2.5);    // double 버전
add(1.0f, 2.0f);  // float 버전

템플릿 인스턴스화 (Template Instantiation)

template<typename T>
void print(T value)
{
    std::cout << value << std::endl;
}

int main()
{
    print(10);      // ✅ print<int>(int) 생성됨
    print(3.14);    // ✅ print<double>(double) 생성됨
    print("hello"); // ✅ print<const char*>(const char*) 생성됨

    return 0;
}

명시적 템플릿 인자 지정

template<typename T>
T getValue()
{
    return T{};
}

int main()
{
    auto x = getValue<int>();     // int 반환
    auto y = getValue<double>();  // double 반환

    return 0;
}

🔸 Template Type Deduction (템플릿 타입 추론)

자동 타입 추론

template<typename T>
void print(T value)
{
    std::cout << value << std::endl;
}

int main()
{
    int x = 10;
    print(x);  // T는 int로 추론됨

    print(3.14);  // T는 double로 추론됨

    return 0;
}

auto 키워드와의 관계

// auto와 template type deduction은 동일한 규칙 사용
template<typename T>
void func(T param) { }

auto x = 42;  // auto는 int로 추론
func(42);     // T는 int로 추론

// 둘 다 같은 타입 추론 규칙을 따름

타입 추론 규칙

template<typename T>
void func1(T param);        // 값으로 받음

template<typename T>
void func2(T& param);       // L-value reference

template<typename T>
void func3(T&& param);      // Universal reference (forwarding reference)

int x = 10;
const int cx = x;
const int& rx = x;

// func1: 값으로 받음 (const, reference 제거)
func1(x);   // T = int
func1(cx);  // T = int (const 제거)
func1(rx);  // T = int (const&에서 const와 & 제거)

// func2: L-value reference
func2(x);   // T = int, param은 int&
func2(cx);  // T = const int, param은 const int&
func2(rx);  // T = const int, param은 const int&

// func3: Universal reference (나중에 설명)

🔸 Universal Reference (Forwarding Reference)

Universal Reference란?

template<typename T>
void printVar(T&& a)  // ✅ Universal reference (T&&)
{
    std::cout << a << std::endl;
}

• T&&는 R-value reference가 아니라 Universal Reference
• L-value와 R-value를 모두 받을 수 있음
• Template에서만 이런 특성을 가짐 (일반 함수의 &&는 R-value reference)

동작 원리: Reference Collapsing

template<typename T>
void printVar(T&& a)
{
    std::cout << a << std::endl;
}

int main()
{
    int x = 10;

    printVar(x);              // L-value 전달
    // T = int&
    // T&& = int& && → int& (reference collapsing)
    // 결과: printVar(int& a)

    printVar(std::move(x));   // R-value 전달
    // T = int
    // T&& = int&&
    // 결과: printVar(int&& a)

    return 0;
}

Reference Collapsing 규칙

T&  &  → T&   // L-value reference
T&  && → T&   // L-value reference
T&& &  → T&   // L-value reference
T&& && → T&&  // R-value reference

// 핵심: & 하나라도 있으면 &, 둘 다 &&일 때만 &&

🔸 std::forward vs std::move

Perfect Forwarding 문제

void process(int& x)  { std::cout << "L-value" << std::endl; }
void process(int&& x) { std::cout << "R-value" << std::endl; }

template<typename T>
void wrapper(T&& arg)
{
    // arg는 이름이 있는 변수이므로 L-value!
    process(arg);  // 항상 L-value로 전달됨
}

int main()
{
    int x = 10;
    wrapper(x);              // L-value 전달했지만
    wrapper(std::move(x));   // R-value 전달했지만
    // 둘 다 process(int&)가 호출됨! ❌

    return 0;
}

std::move 사용 (잘못된 방법)

template<typename T>
void wrapper(T&& arg)
{
    process(std::move(arg));  // ❌ 항상 R-value로 전달
}

int main()
{
    int x = 10;
    wrapper(x);              // L-value인데 R-value로 전달됨! ❌
    wrapper(std::move(x));   // R-value로 전달 ✅

    return 0;
}

std::forward 사용 (올바른 방법)

template<typename T>
void wrapper(T&& arg)
{
    process(std::forward<T>(arg));  // ✅ 원래 타입 그대로 전달
}

int main()
{
    int x = 10;
    wrapper(x);              // L-value로 전달 ✅ process(int&) 호출
    wrapper(std::move(x));   // R-value로 전달 ✅ process(int&&) 호출

    return 0;
}

std::move vs std::forward 비교

// std::move: 무조건 R-value로 캐스팅
template<typename T>
void func1(T&& a)
{
    std::string localVar{std::move(a)};  // 항상 move
}

// std::forward: 원래 타입 유지
template<typename T>
void func2(T&& a)
{
    std::string localVar{std::forward<T>(a)};  // L-value면 copy, R-value면 move
}

int main()
{
    std::string s = "hello";

    func1(s);              // move (원본 s가 비워질 수 있음)
    func1(std::move(s));   // move

    func2(s);              // copy (원본 s 유지)
    func2(std::move(s));   // move

    return 0;
}

핵심 정리

• std::move: 항상 R-value로 변환 (이동 강제)
• std::forward: 원래 값 카테고리 유지 (Perfect Forwarding)
• Universal Reference + std::forward: 가장 효율적인 패턴

🔸 Template Instantiation (템플릿 인스턴스화)

Multiple Type Parameters (여러 타입 매개변수)

template<typename T, typename U>
auto add(T a, U b)  // 서로 다른 타입도 가능
{
    return a + b;
}

int main()
{
    auto result1 = add(1, 2.5);      // T=int, U=double, 반환=double
    auto result2 = add(1.5f, 2);     // T=float, U=int, 반환=float
    auto result3 = add(1L, 2.5);     // T=long, U=double, 반환=double

    return 0;
}

명시적 반환 타입 지정

template<typename R, typename T, typename U>
R add(T a, U b)
{
    return static_cast<R>(a + b);
}

int main()
{
    auto x = add<double>(1, 2);  // 명시적으로 double 반환
    auto y = add<int>(1.5, 2.5); // 명시적으로 int 반환 (4)

    return 0;
}

Non-Type Template Parameters (비타입 템플릿 매개변수)

template<typename T, size_t N>  // N은 컴파일 타임 상수
class Array
{
public:
    T& operator[](size_t index) { return data[index]; }
    size_t size() const { return N; }

private:
    T data[N];
};

int main()
{
    Array<int, 5> arr1;     // int 배열, 크기 5
    Array<double, 10> arr2; // double 배열, 크기 10

    std::cout << arr1.size() << std::endl;  // 5
    std::cout << arr2.size() << std::endl;  // 10

    return 0;
}

비타입 매개변수 제약

• 정수 타입 (int, size_t, long 등)
• 포인터
• 참조
• enum
• C++20부터: 부동소수점, 클래스 타입도 가능

Variadic Templates (가변 인자 템플릿)

// Base case (재귀 종료)
void print()
{
    std::cout << std::endl;
}

// Recursive case
template<typename T, typename... Args>  // Args는 parameter pack
void print(T first, Args... rest)
{
    std::cout << first << " ";
    print(rest...);  // 재귀 호출
}

int main()
{
    print(1, 2, 3, 4, 5);           // 1 2 3 4 5
    print("Hello", 42, 3.14, 'A');  // Hello 42 3.14 A

    return 0;
}

C++17: Fold Expression

template<typename... Args>
auto sum(Args... args)
{
    return (args + ...);  // Fold expression
}

int main()
{
    std::cout << sum(1, 2, 3, 4, 5) << std::endl;        // 15
    std::cout << sum(1.5, 2.5, 3.5) << std::endl;        // 7.5

    return 0;
}

🔸 Template 빌드 (Instantiation)

템플릿은 헤더 파일에 구현해야 함

❌ 잘못된 방법 (.h와 .cpp 분리)

// Math.h
template<typename T>
T add(T a, T b);

// Math.cpp
template<typename T>
T add(T a, T b)
{
    return a + b;
}

// main.cpp
#include "Math.h"
int main()
{
    add(1, 2);  // ❌ 링크 에러!
    // Math.cpp에는 add<int>가 생성되지 않음
    return 0;
}

✅ 올바른 방법 (헤더에 구현)

// Math.h
template<typename T>
T add(T a, T b)  // 헤더에 구현
{
    return a + b;
}

// main.cpp
#include "Math.h"
int main()
{
    add(1, 2);  // ✅ OK
    return 0;
}

이유:

• 템플릿은 사용 시점에 인스턴스화됨
• 컴파일러가 템플릿 정의를 볼 수 있어야 인스턴스화 가능
• .cpp 파일에 숨기면 다른 파일에서 정의를 볼 수 없음

대안: Explicit Instantiation (명시적 인스턴스화)

// Math.h
template<typename T>
T add(T a, T b);

// Math.cpp
template<typename T>
T add(T a, T b)
{
    return a + b;
}

// 사용할 타입을 미리 명시
template int add<int>(int, int);
template double add<double>(double, double);

// main.cpp
#include "Math.h"
int main()
{
    add(1, 2);      // ✅ OK
    add(1.5, 2.5);  // ✅ OK
    // add(1L, 2L); // ❌ 에러! long 버전은 명시하지 않음
    return 0;
}

🔸 Class Template (클래스 템플릿)

기본 사용법

template<typename T>
class Stack
{
public:
    void push(T item)
    {
        data.emplace_back(std::move(item));
    }

    bool pop(T& item)
    {
        if (data.empty()) return false;
        item = std::move(data.back());
        data.pop_back();
        return true;
    }
    bool empty() const { return data.empty(); }

private:
    std::vector<T> data;
};

int main()
{
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);

    Stack<std::string> strStack;
    strStack.push("hello");
    strStack.push("world");

    return 0;
}

C++17: Class Template Argument Deduction (CTAD)

template<typename T>
class Pair
{
public:
    Pair(T a, T b) : first{a}, second{b} {}

    T first;
    T second;
};

int main()
{
    // C++17 이전
    Pair<int> p1{1, 2};

    // C++17 이후: 타입 추론
    Pair p2{1, 2};        // Pair<int>로 추론
    Pair p3{1.5, 2.5};    // Pair<double>로 추론

    return 0;
}

🔸 Template Alias (템플릿 별칭)

using을 이용한 템플릿 별칭

// 복잡한 타입
std::map<std::string, std::vector<std::pair<int, double>>> data;

// Alias로 단순화
template<typename K, typename V>
using DataMap = std::map<K, std::vector<std::pair<int, V>>>;

DataMap<std::string, double> data;  // 훨씬 읽기 쉬움!

부분 특수화와 함께 사용

template<typename T>
using Ptr = std::unique_ptr<T>;

int main()
{
    Ptr<int> intPtr = std::make_unique<int>(42);
    Ptr<std::string> strPtr = std::make_unique<std::string>("hello");

    return 0;
}

🔸 Variable Template (변수 템플릿)

C++14: Variable Template

template<typename T>
constexpr T pi = T{3.1415926535897932385};

int main()
{
    std::cout << pi<float> << std::endl;       // float 정밀도
    std::cout << pi<double> << std::endl;      // double 정밀도
    std::cout << pi<long double> << std::endl; // long double 정밀도

    return 0;
}

타입 특성과 함께 사용

template<typename T>
constexpr bool is_pointer_v = std::is_pointer<T>::value;

int main()
{
    std::cout << is_pointer_v<int*> << std::endl;    // 1 (true)
    std::cout << is_pointer_v<int> << std::endl;     // 0 (false)

    return 0;
}

🔸 Concepts (C++20)

Concepts란?

• 템플릿 매개변수에 제약 조건을 명시하는 기능
• 컴파일 에러 메시지가 명확해짐
• 템플릿 오버로딩이 쉬워짐

requires 키워드

// C++20 이전: 모든 타입 허용
template<typename T>
T add(T a, T b)
{
    return a + b;
}

// C++20: 제약 추가
template<typename T>
requires std::is_arithmetic_v<T>  // 산술 타입만 허용
T add(T a, T b)
{
    return a + b;
}

int main()
{
    add(1, 2);        // ✅ OK
    add(1.5, 2.5);    // ✅ OK
    // add("a", "b"); // ❌ 컴파일 에러! (명확한 에러 메시지)

    return 0;
}

표준 Concepts

#include <concepts>

// std::integral: 정수 타입만
template<std::integral T>
T multiply(T a, T b)
{
    return a * b;
}

// std::floating_point: 부동소수점 타입만
template<std::floating_point T>
T divide(T a, T b)
{
    return a / b;
}

int main()
{
    multiply(2, 3);      // ✅ OK (int)
    // multiply(2.5, 3); // ❌ 에러! (double은 integral이 아님)

    divide(5.0, 2.0);    // ✅ OK (double)
    // divide(5, 2);     // ❌ 에러! (int는 floating_point가 아님)

    return 0;
}

사용자 정의 Concept

// Concept 정의
template<typename T>
concept Printable = requires(T t)
{
    { std::cout << t } -> std::same_as<std::ostream&>;
};

// Concept 사용
template<Printable T>
void print(const T& value)
{
    std::cout << value << std::endl;
}

class MyClass
{
public:
    friend std::ostream& operator<<(std::ostream& os, const MyClass& obj)
    {
        os << "MyClass";
        return os;
    }
};

int main()
{
    print(42);          // ✅ OK
    print("hello");     // ✅ OK
    print(MyClass{});   // ✅ OK (operator<< 정의됨)

    return 0;
}

Concept 조합 (논리 연산자)

template<typename T>
concept Numeric = std::is_arithmetic_v<T>;

template<typename T>
concept Pointer = std::is_pointer_v<T>;

// AND 연산
template<typename T>
concept NumericPointer = Numeric<T> && Pointer<T>;

// OR 연산
template<typename T>
concept NumericOrPointer = Numeric<T> || Pointer<T>;

// NOT 연산
template<typename T>
concept NotPointer = !Pointer<T>;

template<NumericOrPointer T>
void process(T value)
{
    // Numeric이거나 Pointer인 타입만 허용
}

requires 표현식의 다양한 형태

// 1. Simple requirement (단순 요구사항)
template<typename T>
concept HasSize = requires(T t)
{
    t.size();  // size() 메서드가 있어야 함
};

// 2. Type requirement (타입 요구사항)
template<typename T>
concept HasValueType = requires
{
    typename T::value_type;  // value_type이라는 중첩 타입이 있어야 함
};

// 3. Compound requirement (복합 요구사항)
template<typename T>
concept Container = requires(T t)
{
    { t.begin() } -> std::same_as<typename T::iterator>;
    { t.end() } -> std::same_as<typename T::iterator>;
    { t.size() } -> std::convertible_to<size_t>;
};

// 4. Nested requirement (중첩 요구사항)
template<typename T>
concept Sortable = requires(T t)
{
    requires std::is_same_v<decltype(t < t), bool>;
};

🔸 핵심 정리

템플릿 기본

• 컴파일 타임에 타입이 결정되는 제네릭 프로그래밍
• 사용 시점에 인스턴스화 (Instantiation)
• Function overloading보다 효율적

타입 추론과 Perfect Forwarding

• Universal Reference (T&&)는 L-value와 R-value 모두 받음
• std::forward로 원래 값 카테고리 유지 (Perfect Forwarding)
• std::move는 항상 R-value로 변환

템플릿 종류

• Function Template: 함수 템플릿
• Class Template: 클래스 템플릿
• Variable Template: 변수 템플릿 (C++14)
• Alias Template: 템플릿 별칭

고급 기능

• Variadic Templates: 가변 인자 템플릿
• Non-Type Parameters: 비타입 매개변수
• Concepts (C++20): 템플릿 제약 조건

템플릿 빌드

• 헤더 파일에 구현 필수
• 또는 명시적 인스턴스화 사용

<참고 자료>

코드없는 프로그래밍 C++ Templates C++ Concepts

🔸 스마트 포인터가 필요한 이유

Raw Pointer의 문제점

class Cat
{
public:
    Cat() : mAge{0}
    {
        std::cout << "Cat constructor" << std::endl;
    }
    ~Cat()
    {
        std::cout << "Cat destructor" << std::endl;
    }
private:
    int mAge;
};

void foo(Cat* ptr)
{
    Cat* fooPtr = ptr;
    delete fooPtr;  // ptr이 가리키는 객체 해제
}

int main()
{
    Cat* catPtr = new Cat();
    Cat* catPtr1 = catPtr;  // 같은 객체를 가리킴

    foo(catPtr);   // 객체 해제 (1번)
    delete catPtr; // ❌ 이미 해제된 객체를 다시 해제! (Double Delete)
    // Undefined Behavior 발생!

    return 0;
}

발생 가능한 문제들

1. Memory Leak: delete를 잊어버림
2. Double Delete: 같은 메모리를 두 번 해제
3. Dangling Pointer: 해제된 메모리를 가리키는 포인터
4. 소유권 불명확: 누가 메모리를 해제해야 하는지 모호함

🔸 RAII (Resource Acquisition Is Initialization)

RAII란?

• 자원의 획득은 초기화와 함께 이루어져야 한다는 원칙
• 객체의 생성자에서 자원을 획득하고, 소멸자에서 자동으로 해제
• C++의 핵심 디자인 패턴

RAII를 통한 자동 메모리 관리

{
    std::unique_ptr<Cat> catPtr = std::make_unique<Cat>();
    // Cat 객체 생성 및 소유권 설정

    // catPtr 사용...

}  // ✅ 스코프를 벗어나면 자동으로 delete 호출!
   // 명시적 delete 불필요

스마트 포인터의 장점

• 자동 메모리 관리 (RAII)
• 소유권 명확화
• 예외 안전성 보장
• Double Delete 방지

🔸 unique_ptr (Exclusive Ownership)

unique_ptr이란?

• 독점적 소유권을 가지는 스마트 포인터
• 복사 불가능, 이동만 가능
• 가장 가볍고 효율적인 스마트 포인터 (오버헤드 거의 없음)

기본 사용법

#include <memory>

int main()
{
    // ✅ 생성 방법 (C++14 이상)
    std::unique_ptr<Cat> catPtr = std::make_unique<Cat>();

    // C++11 방식
    std::unique_ptr<Cat> catPtr2{new Cat()};

    // 사용
    catPtr->someMethod();
    (*catPtr).someMethod();

    // ✅ 자동으로 delete 호출됨
    return 0;
}

복사 불가능, 이동 가능

std::unique_ptr<Cat> catPtr1 = std::make_unique<Cat>();

// ❌ 복사 불가능
std::unique_ptr<Cat> catPtr2 = catPtr1;  // 컴파일 에러!

// ✅ 이동 가능 (소유권 이전)
std::unique_ptr<Cat> catPtr3 = std::move(catPtr1);
// catPtr1은 이제 nullptr
// catPtr3이 객체의 소유권을 가짐

함수 인자로 전달

// ❌ 값으로 전달 (소유권 이전, 원본은 nullptr)
void foo(std::unique_ptr<Cat> ptr)
{
    // ptr이 소유권을 가짐
}  // 여기서 객체 자동 해제

// ✅ 참조로 전달 (소유권 유지, 일시적 사용)
void bar(const std::unique_ptr<Cat>& ptr)
{
    // ptr 사용
}  // 소유권은 호출자가 계속 유지

// ✅ Raw 포인터로 전달 (소유권과 무관하게 사용)
void baz(Cat* ptr)
{
    // ptr 사용
}

int main()
{
    auto catPtr = std::make_unique<Cat>();

    // foo(catPtr);  // ❌ 복사 불가
    foo(std::move(catPtr));  // ✅ 소유권 이전, catPtr은 nullptr

    auto catPtr2 = std::make_unique<Cat>();
    bar(catPtr2);  // ✅ 소유권 유지
    baz(catPtr2.get());  // ✅ Raw 포인터 전달

    return 0;
}

🔸 unique_ptr을 멤버 변수로 사용

클래스 멤버로 사용의 장점

class Zoo
{
public:
    Zoo() : mCat{std::make_unique<Cat>()} {}

    // ✅ 소멸자에서 자동으로 delete 호출됨
    ~Zoo() = default;  // 명시적 delete 불필요!

private:
    std::unique_ptr<Cat> mCat;  // 자동 메모리 관리
};

주의사항: Copy 불가능

class Zoo
{
public:
    Zoo() : mCat{std::make_unique<Cat>()} {}

private:
    std::unique_ptr<Cat> mCat;
};

int main()
{
    Zoo zoo1;
    Zoo zoo2 = zoo1;  // ❌ 컴파일 에러!
    // unique_ptr은 복사 불가능하므로
    // default copy constructor가 delete됨

    return 0;
}

해결 방법 1: Copy Constructor/Assignment Delete

class Zoo
{
public:
    Zoo() : mCat{std::make_unique<Cat>()} {}

    // ✅ 명시적으로 복사 금지
    Zoo(const Zoo&) = delete;
    Zoo& operator=(const Zoo&) = delete;

    // ✅ 이동은 허용
    Zoo(Zoo&&) = default;
    Zoo& operator=(Zoo&&) = default;

private:
    std::unique_ptr<Cat> mCat;
};

해결 방법 2: Deep Copy 구현

class Zoo
{
public:
    Zoo() : mCat{std::make_unique<Cat>()} {}

    // Deep copy constructor
    Zoo(const Zoo& other)
        : mCat{other.mCat ? std::make_unique<Cat>(*other.mCat) : nullptr}
    {
    }

    // Deep copy assignment
    Zoo& operator=(const Zoo& other)
    {
        if (this != &other)
        {
            mCat = other.mCat ? std::make_unique<Cat>(*other.mCat) : nullptr;
        }
        return *this;
    }

private:
    std::unique_ptr<Cat> mCat;
};

unique_ptr 사용 가이드라인

• 기본 선택: 포인터가 필요하면 먼저 unique_ptr 고려
• 소유권 명확: 한 객체가 자원을 독점적으로 소유
• 성능: Raw 포인터와 동일한 성능 (오버헤드 없음)
• 배열 지원: std::unique_ptr<int[]> (하지만 std::vector 권장)

🔸 shared_ptr (Shared Ownership)

shared_ptr이란?

• 공유 소유권을 가지는 스마트 포인터
• 참조 카운팅(Reference Counting)을 통해 관리
• 마지막 shared_ptr이 소멸될 때 객체 자동 해제

기본 사용법

#include <memory>

int main()
{
    // ✅ 생성 (C++11 이상)
    std::shared_ptr<Cat> catPtr1 = std::make_shared<Cat>();

    {
        // 복사 가능 (참조 카운트 증가)
        std::shared_ptr<Cat> catPtr2 = catPtr1;  // ✅ OK
        std::shared_ptr<Cat> catPtr3 = catPtr1;

        // 참조 카운트 확인
        std::cout << catPtr1.use_count() << std::endl;  // 3

    }  // catPtr2, catPtr3 소멸 (참조 카운트 감소)

    std::cout << catPtr1.use_count() << std::endl;  // 1

    return 0;
}  // catPtr1 소멸, 참조 카운트 0 → Cat 객체 자동 해제

참조 카운팅 동작 원리

std::shared_ptr<Cat> ptr1 = std::make_shared<Cat>();  // count: 1
std::shared_ptr<Cat> ptr2 = ptr1;   // count: 2 (복사)
std::shared_ptr<Cat> ptr3 = ptr2;   // count: 3 (복사)

ptr3.reset();  // count: 2 (ptr3이 소유권 포기)
ptr2 = nullptr;  // count: 1
// ptr1만 남음

// ptr1이 소멸되면 count: 0 → 객체 자동 해제

Control Block

shared_ptr 구조:
┌───────────────┐
│ Data Pointer │ → Cat 객체
├───────────────┤
│ Control Block│ → ┌──────────────────┐
└───────────────┘   │ Reference Count │
                   │ Weak Count      │
                   │ Deleter         │
                   └──────────────────┘

• shared_ptr은 실제 객체 외에 Control Block이라는 추가 메모리 필요
• Control Block에는 참조 카운트와 관리 정보 저장
• 메모리 오버헤드: 포인터 8 bytes + Control Block 약 16-24 bytes

🔸 shared_ptr을 멤버 변수로 사용 시 주의사항

문제 상황: 얕은 복사

class Zoo
{
public:
    Zoo() : mCat{std::make_shared<Cat>()} {}

    // Default copy constructor 사용
    // Zoo(const Zoo& other) = default;

private:
    std::shared_ptr<Cat> mCat;
};

int main()
{
    Zoo zoo1;
    Zoo zoo2 = zoo1;  // ✅ 복사 가능 (shared_ptr은 복사 가능)

    // ❌ 문제: zoo1과 zoo2가 같은 Cat 객체를 공유!
    // zoo1에서 Cat을 수정하면 zoo2에도 영향

    return 0;
}

해결 방법 1: 주석으로 명시

class Zoo
{
public:
    Zoo() : mCat{std::make_shared<Cat>()} {}

    // ⚠️ Warning: This class uses shared_ptr.
    // Copy constructor performs shallow copy.
    // Both instances will share the same Cat object.

private:
    std::shared_ptr<Cat> mCat;
};

해결 방법 2: Deep Copy 함수 제공

class Zoo
{
public:
    Zoo() : mCat{std::make_shared<Cat>()} {}

    // Shallow copy는 default 사용
    Zoo(const Zoo&) = default;
    Zoo& operator=(const Zoo&) = default;

    // ✅ Deep copy를 위한 별도 함수 제공
    Zoo deepCopy() const
    {
        Zoo newZoo;
        newZoo.mCat = std::make_shared<Cat>(*mCat);  // 새로운 Cat 객체 생성
        return newZoo;
    }

private:
    std::shared_ptr<Cat> mCat;
};

int main()
{
    Zoo zoo1;
    Zoo zoo2 = zoo1;           // Shallow copy
    Zoo zoo3 = zoo1.deepCopy(); // Deep copy ✅

    return 0;
}

해결 방법 3: Deep Copy를 기본으로 구현

class Zoo
{
public:
    Zoo() : mCat{std::make_shared<Cat>()} {}

    // Deep copy constructor
    Zoo(const Zoo& other)
        : mCat{other.mCat ? std::make_shared<Cat>(*other.mCat) : nullptr}
    {
    }

    // Deep copy assignment
    Zoo& operator=(const Zoo& other)
    {
        if (this != &other)
        {
            mCat = other.mCat ? std::make_shared<Cat>(*other.mCat) : nullptr;
        }
        return *this;
    }

private:
    std::shared_ptr<Cat> mCat;
};

🔸 순환 참조 문제 (Circular Reference)

Memory Leak 발생 상황

class Node
{
public:
    std::shared_ptr<Node> next;  // 다음 노드를 가리킴

    ~Node()
    {
        std::cout << "Node destroyed" << std::endl;
    }
};

int main()
{
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2;  // node1 → node2 (node2 count: 2)
    node2->next = node1;  // node2 → node1 (node1 count: 2)

    // ❌ 순환 참조 발생!
    // node1, node2가 스코프를 벗어나도
    // 서로를 참조하고 있어서 count가 0이 되지 않음
    // → Memory Leak!

    return 0;
}
// "Node destroyed" 출력되지 않음!

순환 참조 메모리 구조

node1 (count: 2) → next → node2 (count: 2)
  ↑                         ↓
  └────────── next ──────────┘

main 함수 종료 후:
node1 (count: 1) → next → node2 (count: 1)
  ↑                         ↓
  └────────── next ──────────┘

count가 모두 1이므로 해제되지 않음!

다른 언어의 해결 방법: Garbage Collection

// Java, C#, Python 등
// GC가 Mark and Sweep 알고리즘으로 순환 참조 감지 및 해제
// 1. Mark: 루트에서 도달 가능한 객체 표시
// 2. Sweep: 표시되지 않은 객체 해제

C++에는 GC가 없으므로 weak_ptr로 해결해야 함

🔸 weak_ptr (순환 참조 해결)

weak_ptr이란?

• 참조 카운팅에 영향을 주지 않는 약한 참조
• 순환 참조 문제 해결
• 객체를 관찰(observe)만 하고, 소유하지 않음
• 사용 전에 shared_ptr로 변환 필요

순환 참조 해결

class Node
{
public:
    std::shared_ptr<Node> next;     // 강한 참조
    std::weak_ptr<Node> prev;       // ✅ 약한 참조 (카운트 증가 X)

    ~Node()
    {
        std::cout << "Node destroyed" << std::endl;
    }
};

int main()
{
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2;    // node1 → node2 (node2 count: 2)
    node2->prev = node1;    // node2 ⇢ node1 (node1 count: 1, weak!)

    // ✅ 순환 참조 해결!
    // node1 count: 1, node2 count: 2

    return 0;
}
// node1 소멸 → node1 count: 0 → node1 해제
// node2 소멸 → node2 count: 0 → node2 해제
// "Node destroyed" 두 번 출력됨! ✅

weak_ptr 사용 방법

class Observer
{
public:
    void observe(std::shared_ptr<Cat> cat)
    {
        mWeakCat = cat;  // weak_ptr에 저장 (카운트 증가 X)
    }

    void check()
    {
        // weak_ptr을 shared_ptr로 변환 (lock)
        if (auto sharedCat = mWeakCat.lock())  // ✅ 객체가 존재하면
        {
            // 안전하게 사용
            sharedCat->meow();
        }
        else
        {
            std::cout << "Cat is gone!" << std::endl;  // ❌ 객체가 이미 해제됨
        }
    }

private:
    std::weak_ptr<Cat> mWeakCat;  // 약한 참조
};

int main()
{
    Observer observer;

    {
        auto cat = std::make_shared<Cat>();
        observer.observe(cat);
        observer.check();  // ✅ "Cat exists"

    }  // cat 소멸

    observer.check();  // ❌ "Cat is gone!"

    return 0;
}

weak_ptr 주요 메서드

std::weak_ptr<Cat> weakPtr;

// shared_ptr로 변환 (객체가 존재하면 shared_ptr 반환, 아니면 nullptr)
std::shared_ptr<Cat> sharedPtr = weakPtr.lock();

// 객체가 해제되었는지 확인
bool expired = weakPtr.expired();  // true면 객체 해제됨

// 참조 카운트 확인
long count = weakPtr.use_count();  // shared_ptr의 참조 카운트

🔸 스마트 포인터 선택 가이드

언제 어떤 스마트 포인터를 사용할까?

일반적인 사용 패턴

// ✅ 1순위: unique_ptr (독점 소유)
std::unique_ptr<Cat> catPtr = std::make_unique<Cat>();

// ✅ 2순위: shared_ptr (공유 필요)
std::shared_ptr<Cat> catPtr = std::make_shared<Cat>();

// ✅ 3순위: weak_ptr (순환 참조 방지, 관찰만)
std::weak_ptr<Cat> weakCat = sharedCat;

// ❌ Raw pointer는 최후의 수단
Cat* rawPtr = new Cat();  // 피하기!
delete rawPtr;

성능 비교

// Raw pointer: 8 bytes
Cat* raw;

// unique_ptr: 8 bytes (오버헤드 없음)
std::unique_ptr<Cat> unique;

// shared_ptr: 16 bytes (포인터 8 + Control Block 포인터 8)
//             + Control Block 16-24 bytes
std::shared_ptr<Cat> shared;

// weak_ptr: 16 bytes (shared_ptr과 동일)
std::weak_ptr<Cat> weak;

🔸 핵심 정리

unique_ptr

• 독점 소유권, 복사 불가, 이동 가능
• 오버헤드 없음, 가장 효율적
• 멤버 변수로 사용 시 복사 생성자 주의
• 기본 선택지

shared_ptr

• 공유 소유권, 참조 카운팅
• 복사 가능, 메모리 오버헤드 있음
• 순환 참조 주의 (Memory Leak 가능)
• 멤버 변수로 사용 시 얕은 복사 주의

weak_ptr

• 참조 카운팅에 영향 없음
• 순환 참조 해결
• 사용 전 lock()으로 shared_ptr 변환 필요
• Observer 패턴, 캐시 구현에 유용

Best Practices

1. Raw pointer 대신 스마트 포인터 사용
2. 기본은 unique_ptr, 필요시 shared_ptr
3. 순환 참조는 weak_ptr로 해결
4. make_unique/make_shared 사용 권장
5. 멤버 변수로 사용 시 복사 의미 명확히

<참고 자료>

코드없는 프로그래밍 C++ Smart Pointers RAII

🔸 Multiple Inheritance (다중 상속)

다중 상속이란?

• 하나의 클래스가 여러 부모 클래스를 동시에 상속받는 것
• C++에서는 가능하지만 Java, C#에서는 금지됨 (인터페이스만 다중 구현 가능)

기본 문법

class Lion : public Animal
{
public:
    void roar() { std::cout << "Roar!" << std::endl; }
};

class Tiger : public Animal
{
public:
    void growl() { std::cout << "Growl!" << std::endl; }
};

class Liger : public Lion, public Tiger  // 다중 상속
{
public:
    void speak() { std::cout << "Liger sound" << std::endl; }
};

🔸 Diamond Problem (다이아몬드 문제)

문제 상황

class Animal
{
public:
    Animal() { std::cout << "Animal constructor" << std::endl; }
    virtual ~Animal() { std::cout << "Animal destructor" << std::endl; }
    void breathe() { std::cout << "Breathing" << std::endl; }
protected:
    int age;
};

class Lion : public Animal
{
public:
    Lion() { std::cout << "Lion constructor" << std::endl; }
};

class Tiger : public Animal
{
public:
    Tiger() { std::cout << "Tiger constructor" << std::endl; }
};

class Liger : public Lion, public Tiger
{
public:
    Liger() { std::cout << "Liger constructor" << std::endl; }
};

int main()
{
    Liger liger;
    // 출력:
    // Animal constructor  ← Lion을 위한 Animal
    // Lion constructor
    // Animal constructor  ← Tiger를 위한 Animal (중복!)
    // Tiger constructor
    // Liger constructor

    // liger.breathe();  // ❌ 컴파일 에러! Lion의 breathe? Tiger의 breathe?
    // liger.age = 5;    // ❌ 컴파일 에러! 어느 Animal의 age?

    return 0;
}

문제점:

1. Animal 생성자가 2번 호출됨 (메모리 낭비)
2. Liger 객체 안에 Animal이 2개 존재 (모호성)
3. Animal의 멤버에 접근할 때 어느 것인지 불명확

메모리 구조 (일반 다중 상속)

Liger 객체:
┌────────────────┐
│ Lion 부분      │
│  - Animal     │  ← 첫 번째 Animal
│  - Lion 데이터 │
├─────────────────┤
│ Tiger 부분     │
│  - Animal     │  ← 두 번째 Animal (중복!)
│  - Tiger 데이터│
├─────────────────┤
│ Liger 데이터    │
└─────────────────┘

🔸 Virtual Inheritance (가상 상속)

해결 방법: Virtual Inheritance 사용

class Animal
{
public:
    Animal() { std::cout << "Animal constructor" << std::endl; }
    virtual ~Animal() { std::cout << "Animal destructor" << std::endl; }
    virtual void speak() = 0;
protected:
    double animalData;  // 8 bytes
};

class Lion : public virtual Animal  // ✅ virtual 키워드 추가
{
public:
    Lion() { std::cout << "Lion constructor" << std::endl; }
    void speak() override { std::cout << "Roar!" << std::endl; }
protected:
    double lionData;  // 8 bytes
};

class Tiger : public virtual Animal  // ✅ virtual 키워드 추가
{
public:
    Tiger() { std::cout << "Tiger constructor" << std::endl; }
    void speak() override { std::cout << "Growl!" << std::endl; }
protected:
    double tigerData;  // 8 bytes
};

class Liger : public Lion, public Tiger
{
public:
    Liger() { std::cout << "Liger constructor" << std::endl; }
    void speak() override { std::cout << "Liger sound" << std::endl; }
};

int main()
{
    Liger liger;
    // 출력:
    // Animal constructor  ← 단 1번만 호출됨! ✅
    // Lion constructor
    // Tiger constructor
    // Liger constructor

    liger.speak();     // ✅ OK - "Liger sound"
    // liger.animalData = 5.0;  // ✅ 모호성 해결! (protected라 직접 접근은 불가)

    return 0;
}

가상 상속의 효과

• Animal 생성자가 단 1번만 호출됨
• Liger 객체 안에 Animal이 1개만 존재
• 멤버 접근 모호성 해결

🔸 메모리 레이아웃 비교

일반 상속 vs 가상 상속의 메모리 크기 변화

1. 일반 상속 (Lion만 있을 때)

class Lion : public Animal
{
protected:
    double lionData;  // 8 bytes
};

// sizeof(Lion) = 24 bytes
// [vptr: 8] [animalData: 8] [lionData: 8]

2. 가상 상속 (Lion만 있을 때)

class Lion : public virtual Animal
{
protected:
    double lionData;  // 8 bytes
};

// sizeof(Lion) = 32 bytes
// [Lion vptr: 8] [lionData: 8] [Animal vptr: 8] [animalData: 8]

메모리 구조 상세 비교

일반 상속 Lion (24 bytes):
┌─────────────┐
│ vptr (8B)  │ → VTable
├─────────────┤
│ animalData │
├─────────────┤
│ lionData   │
└─────────────┘

가상 상속 Lion (32 bytes):
┌──────────────┐
│ Lion vptr   │ → Lion VTable (offset 포함)
├──────────────┤
│ lionData    │
├──────────────┤
│ Animal vptr │ → Animal VTable
├──────────────┤
│ animalData  │
└──────────────┘

가상 상속이 더 큰 이유:

• VTable이 2개 필요 (Lion용, Animal용)
• Lion VTable에 offset 정보 추가 저장
• Animal 데이터의 위치가 동적으로 결정됨

🔸 Thunk와 Offset

일반 상속에서의 함수 호출

Animal* polyLion = new Lion();
polyLion->speak();  // Lion의 speak 직접 호출

• Lion의 데이터 위치가 고정되어 있어서 offset 계산 불필요
• VTable에서 함수 주소를 바로 호출

가상 상속에서의 함수 호출

Animal* polyLion = new Lion();  // Animal 포인터로 가상 상속된 Lion 참조
polyLion->speak();

문제: Animal* 포인터는 객체의 Animal 부분을 가리킴. 하지만 가상 상속에서는 Lion 데이터가 Animal 데이터와 떨어져 있음!

해결: Thunk 사용

Lion VTable (가상 상속):
┌─────────────────────────┐
│ offset to Animal: +16 │ ← offset 정보
├─────────────────────────┤
│ &Lion::speak [thunk]  │ ← thunk 함수
└─────────────────────────┘

Thunk 함수:
1. this 포인터를 offset만큼 조정
2. 실제 Lion::speak() 호출

Thunk란?

• 포인터를 조정(adjust)하는 작은 함수
• this 포인터에 offset을 더해서 올바른 위치로 이동
• 가상 상속에서만 필요 (일반 상속에서는 불필요)

포인터 타입에 따른 VTable 선택

Lion lion;

// Lion* 타입: offset 계산 불필요
Lion* lionPtr = &lion;
lionPtr->speak();  // thunk 없는 VTable 사용 (빠름)

// Animal* 타입: offset 계산 필요
Animal* animalPtr = &lion;
animalPtr->speak();  // thunk 있는 VTable 사용 (느림)

가상 상속의 성능 비용

• VTable이 커짐 (offset 정보 + thunk 함수 포인터)
• 간접 참조가 한 단계 더 추가됨
• 메모리 오버헤드 증가

🔸 다중 상속 사용 지침

다중 상속을 피해야 하는 이유

1. 복잡성 증가: 코드 이해와 유지보수 어려움
2. 다이아몬드 문제: 가상 상속으로 해결 가능하지만 복잡도 증가
3. 성능 오버헤드: 가상 상속은 메모리와 성능 비용 발생
4. 모호성: 같은 이름의 멤버가 여러 부모에 있을 때 충돌

다중 상속이 허용되는 경우

// ✅ OK: 여러 인터페이스 구현
class ISerializable
{
public:
    virtual std::string serialize() = 0;
    virtual ~ISerializable() = default;
};

class ILoggable
{
public:
    virtual void log() = 0;
    virtual ~ILoggable() = default;
};

class User : public ISerializable, public ILoggable
{
    // 순수 가상 함수만 있는 인터페이스는 다중 상속 OK
};

권장 설계 패턴

• 인터페이스 다중 구현: ✅ 안전
• 구현 클래스 다중 상속: ❌ 위험
• Composition over Inheritance: 상속 대신 포함 관계 사용

// ❌ 나쁜 설계: 구현 클래스 다중 상속
class Liger : public Lion, public Tiger { };

// ✅ 좋은 설계: Composition 사용
class Liger : public Animal
{
    Lion lionBehavior;   // Lion을 포함
    Tiger tigerBehavior; // Tiger를 포함
};

🔸 Object Slicing (객체 잘림 현상)

Object Slicing이란?

• 자식 객체를 부모 타입 값(value) 으로 복사할 때 자식 부분이 잘려나가는 현상
• 포인터나 참조에서는 발생하지 않음

문제 상황

class Animal
{
public:
    virtual void speak() { std::cout << "Animal sound" << std::endl; }
protected:
    double weight;
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }
private:
    std::string name;  // Cat만의 데이터
};

int main()
{
    Cat kitty;
    kitty.speak();  // "Meow~"

    // ✅ 참조: Object Slicing 없음
    Animal& animalRef = kitty;
    animalRef.speak();  // "Meow~" (가상 함수 정상 동작)

    // ❌ 값 복사: Object Slicing 발생!
    Animal animalObj = kitty;  // Cat의 name이 잘려나감!
    animalObj.speak();  // "Animal sound" (Cat의 speak가 아님!)

    // sizeof 확인
    std::cout << "sizeof(Cat): " << sizeof(Cat) << std::endl;      // 40 bytes
    std::cout << "sizeof(animalObj): " << sizeof(animalObj) << std::endl;  // 16 bytes
    // Cat의 name이 사라짐!

    return 0;
}

Object Slicing이 발생하는 상황

void feedAnimal(Animal animal)  // ❌ 값으로 받음
{
    animal.speak();  // 항상 "Animal sound"
}

Cat kitty;
feedAnimal(kitty);  // Object Slicing 발생!

메모리 구조

Cat 객체 (원본):

┌──────────┐
│ vptr    │
├──────────┤
│ weight  │
├──────────┤
│ name    │  ← Cat 고유 데이터
└──────────┘

Animal animalObj = kitty 복사 후:

🔸 Object Slicing 방지 방법

방법 1: Copy Constructor를 Protected로 선언

class Animal
{
public:
    virtual void speak() = 0;
    virtual ~Animal() = default;

protected:
    Animal() = default;
    Animal(const Animal&) = default;  // ✅ protected 복사 생성자
    Animal& operator=(const Animal&) = default;
};

int main()
{
    Cat kitty;
    Animal animalObj = kitty;  // ❌ 컴파일 에러! protected라 접근 불가
    return 0;
}

방법 2: Copy Constructor를 Delete

class Animal
{
public:
    virtual void speak() = 0;
    virtual ~Animal() = default;

    Animal(const Animal&) = delete;  // ✅ 복사 금지
    Animal& operator=(const Animal&) = delete;

protected:
    Animal() = default;
};

방법 3: Pure Abstract Class로 만들기 (가장 권장)

class IAnimal  // 인터페이스
{
public:
    virtual void speak() = 0;
    virtual ~IAnimal() = default;

protected:
    IAnimal() = default;
    IAnimal(const IAnimal&) = delete;
    IAnimal& operator=(const IAnimal&) = delete;
};

// 구체 클래스는 복사 가능
class Cat : public IAnimal
{
public:
    Cat() = default;
    Cat(const Cat&) = default;  // ✅ Cat끼리는 복사 가능
    void speak() override { std::cout << "Meow~" << std::endl; }
};

int main()
{
    Cat kitty1;
    Cat kitty2 = kitty1;  // ✅ OK - Cat끼리는 복사 가능

    IAnimal* ptr = &kitty1;
    // IAnimal obj = *ptr;  // ❌ 컴파일 에러! IAnimal은 추상 클래스

    return 0;
}

올바른 함수 파라미터 설계

// ❌ 나쁜 설계: 값으로 받음 (Object Slicing)
void feedAnimal(Animal animal) { }

// ✅ 좋은 설계: 참조로 받음
void feedAnimal(const Animal& animal) { }

// ✅ 좋은 설계: 포인터로 받음
void feedAnimal(Animal* animal) { }

🔸 상속에서의 Operator Overloading 문제

문제 상황

class Animal
{
public:
    virtual void speak() { std::cout << "Animal" << std::endl; }

    bool operator==(const Animal& other) const
    {
        return weight == other.weight;
    }

protected:
    double weight;
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }

    // operator==를 재정의하지 않음!
private:
    std::string name;
};

int main()
{
    Cat kitty1;
    Cat kitty2;

    if (kitty1 == kitty2)  // ❌ Animal::operator==가 호출됨
    {                       // name은 비교하지 않음!
        std::cout << "Same cats" << std::endl;
    }

    return 0;
}

문제점:

• 자식 클래스에서 operator==를 재정의하지 않으면 부모의 연산자가 사용됨
• 자식 클래스의 추가 멤버는 비교되지 않음

해결 방법: 자식 클래스에서 재정의

class Cat : public Animal
{
public:
    bool operator==(const Cat& other) const
    {
        // 부모의 멤버도 비교
        return Animal::operator==(other) && name == other.name;
    }

private:
    std::string name;
};

더 나은 해결: 가상 함수로 만들기

class Animal
{
public:
    virtual bool equals(const Animal& other) const
    {
        return weight == other.weight;
    }

protected:
    double weight;
};

class Cat : public Animal
{
public:
    bool equals(const Animal& other) const override
    {
        // dynamic_cast로 Cat인지 확인
        const Cat* catPtr = dynamic_cast<const Cat*>(&other);
        if (!catPtr) return false;

        return Animal::equals(other) && name == catPtr->name;
    }

private:
    std::string name;
};

🔸 Dynamic Cast와 RTTI

RTTI (Run-Time Type Information)

• 런타임에 객체의 실제 타입을 확인하는 기능
• dynamic_cast, typeid 연산자 사용
• 성능 오버헤드와 설계 문제로 사용을 피하는 것이 좋음

Upcasting (업캐스팅): 항상 안전

Cat kitty;
Animal* ptr = &kitty;  // ✅ OK - 자식 → 부모 (안전)

Downcasting (다운캐스팅): 위험

Animal* animalPtr = getAnimal();  // 실제로 무엇인지 모름

// ❌ static_cast: 위험! 타입 체크 없음
Cat* catPtr = static_cast<Cat*>(animalPtr);
catPtr->meow();  // animalPtr이 실제로 Cat이 아니면 Undefined Behavior!

// ⚠️ dynamic_cast: 안전하지만 권장하지 않음
Cat* catPtr2 = dynamic_cast<Cat*>(animalPtr);
if (catPtr2)  // nullptr 체크 필요
{
    catPtr2->meow();  // ✅ 안전
}
else
{
    std::cout << "Not a Cat!" << std::endl;
}

dynamic_cast 동작 원리

Animal* ptr = &someObject;
Cat* catPtr = dynamic_cast<Cat*>(ptr);

// 내부 동작:
// 1. ptr이 가리키는 객체의 VTable 확인
// 2. VTable의 type_info 조회
// 3. 상속 계층 구조를 검사
// 4. Cat으로 안전하게 변환 가능하면 포인터 반환
// 5. 불가능하면 nullptr 반환

dynamic_cast를 피해야 하는 이유

1. 성능 오버헤드

   • VTable 탐색과 타입 체크 비용
   • 상속 계층이 깊을수록 느려짐

2. 설계 문제의 신호

   // ❌ 나쁜 설계: 타입 체크
   void process(Animal* animal)
   {
       if (Cat* cat = dynamic_cast<Cat*>(animal))
       {
           cat->meow();
       }
       else if (Dog* dog = dynamic_cast<Dog*>(animal))
       {
           dog->bark();
       }
       // 새로운 동물이 추가되면 이 코드를 수정해야 함!
   }
   
   // ✅ 좋은 설계: 가상 함수 사용
   void process(Animal* animal)
   {
       animal->speak();  // 각 클래스가 자신의 방식으로 speak 구현
   }

3. Open-Closed Principle 위반

   • 새로운 타입 추가 시 기존 코드 수정 필요

올바른 대안: Virtual Function 사용

class Animal
{
public:
    virtual void makeSound() = 0;
    virtual void play() = 0;
    virtual ~Animal() = default;
};

class Cat : public Animal
{
public:
    void makeSound() override { std::cout << "Meow~" << std::endl; }
    void play() override { std::cout << "Playing with yarn" << std::endl; }
};

class Dog : public Animal
{
public:
    void makeSound() override { std::cout << "Woof!" << std::endl; }
    void play() override { std::cout << "Playing fetch" << std::endl; }
};

// ✅ 타입 체크 없이 처리
void interact(Animal* animal)
{
    animal->makeSound();
    animal->play();
    // 새로운 동물이 추가되어도 이 코드는 수정 불필요!
}

dynamic_cast가 허용되는 경우

• 레거시 코드와의 상호작용
• 외부 라이브러리의 제약
• 정말로 타입 정보가 필요한 특수한 경우 (예: 직렬화, 리플렉션)

🔸 상속 설계 Best Practices

1. Base 클래스는 Pure Abstract Class로 만들기

// ✅ 권장: 인터페이스
class IAnimal
{
public:
    virtual void speak() = 0;
    virtual void eat() = 0;
    virtual ~IAnimal() = default;

protected:
    IAnimal() = default;
    IAnimal(const IAnimal&) = delete;
    IAnimal& operator=(const IAnimal&) = delete;
};

이유:

• Object Slicing 방지
• 다형성 강제
• 명확한 인터페이스 정의

2. Composition over Inheritance

// ❌ 상속 남용
class Stack : public std::vector<int>
{
    // vector의 모든 기능이 노출됨 (insert, erase 등)
};

// ✅ Composition 사용
class Stack
{
public:
    void push(int value) { data.push_back(value); }
    int pop() { int val = data.back(); data.pop_back(); return val; }

private:
    std::vector<int> data;  // 포함 관계
};

3. 가상 소멸자 필수

class Base
{
public:
    virtual ~Base() = default;  // ✅ 필수!
};

4. override 키워드 사용

class Derived : public Base
{
public:
    void func() override;  // ✅ 오버라이드 의도 명확히
};

5. final 키워드로 상속 제한

class FinalClass final  // 더 이상 상속 불가
{
};

class Base
{
public:
    virtual void func() final;  // 이 함수는 더 이상 오버라이드 불가
};

6. 다중 상속은 인터페이스로만

// ✅ OK: 인터페이스 다중 구현
class Serializable : public ISerializable, public ILoggable { };

// ❌ 피하기: 구현 클래스 다중 상속
class Liger : public Lion, public Tiger { };

🔸 핵심 정리

다중 상속 관련

• 다이아몬드 문제: 가상 상속으로 해결 가능하지만 복잡도와 성능 비용 증가
• 가상 상속: offset과 thunk로 인한 메모리 및 성능 오버헤드
• 권장: 인터페이스 다중 구현만 사용, 구현 클래스 다중 상속 피하기

Object Slicing

• 원인: 자식 객체를 부모 타입 값으로 복사
• 해결: 복사 생성자 protected/delete, Pure Abstract Class 사용
• 함수 파라미터: 항상 참조나 포인터로 받기

Dynamic Cast와 RTTI

• 피해야 하는 이유: 성능 오버헤드, 설계 문제의 신호
• 대안: Virtual Function으로 다형성 구현
• 허용되는 경우: 레거시 코드, 외부 라이브러리 제약

설계 원칙

1. Base 클래스는 Pure Abstract Class로
2. Composition over Inheritance
3. 가상 소멸자 필수
4. override/final 키워드 활용
5. 인터페이스 다중 구현만 허용

<참고 자료>

코드없는 프로그래밍 C++ Multiple Inheritance C++ Virtual Inheritance

🔸 상속 (Inheritance)

상속의 목적

1. Class Relationship (클래스 관계 표현)

   • "is-a" 관계를 코드로 표현
   • 예: Cat is an Animal, Dog is an Animal

2. Code Reuse (코드 재사용)

   • 공통 기능을 부모 클래스에 구현
   • 자식 클래스에서 중복 코드 제거

3. Class Interface Consistency (일관된 인터페이스)

   • 같은 부모를 상속받은 클래스들은 동일한 인터페이스 제공
   • 다형성(Polymorphism) 구현의 기반

🔸 상속 접근 지정자 (public/protected/private)

접근 지정자에 따른 멤버 접근 권한 변화

class Base
{
public:
    int x;
protected:
    int y;
private:
    int z;
};

1. public 상속 (가장 일반적)

class Derived : public Base
{
    // x는 public 유지
    // y는 protected 유지
    // z는 접근 불가 (private은 항상 접근 불가)
};

• 부모 클래스의 접근 지정자를 그대로 유지
• "is-a" 관계를 표현할 때 사용
• 대부분의 경우 public 상속을 사용함

2. protected 상속 (드물게 사용)

class Derived : protected Base
{
    // x는 protected로 변경
    // y는 protected 유지
    // z는 접근 불가
};

• 부모의 public 멤버가 protected로 변경
• 외부에서 부모 클래스의 인터페이스 접근 차단
• "implemented-in-terms-of" 관계

3. private 상속 (클래스의 기본값)

class Derived : private Base  // class는 기본값이 private
{
    // x는 private로 변경
    // y는 private로 변경
    // z는 접근 불가
};

• 모든 상속받은 멤버가 private로 변경
• 구현 상속일 때 사용 (인터페이스 상속이 아님)
• 일반적으로 Composition(구성)을 사용하는 것이 더 명확함

접근 권한 정리 표

실전 가이드라인

• 99%의 경우 public 상속을 사용
• protected/private 상속은 특수한 경우에만 사용
• private 상속 대신 멤버 변수로 포함(Composition)하는 것을 권장

// ❌ Private 상속 (혼란스러움)
class Car : private Engine { };

// ✅ Composition (명확함)
class Car {
    Engine engine;  // Car has an Engine
};

🔸 Virtual Function (가상 함수)

가상 함수가 필요한 이유

class Animal
{
public:
    void speak()  // 일반 함수
    {
        std::cout << "Animal sound" << std::endl;
    }
};

class Cat : public Animal
{
public:
    void speak()  // 함수 재정의 (Overriding)
    {
        std::cout << "Meow~" << std::endl;
    }
};

int main()
{
    Cat kitty;
    Animal* ptr = &kitty;  // 부모 타입 포인터로 자식 객체 참조

    ptr->speak();  // ❌ "Animal sound" 출력 (Cat의 speak가 아님!)
    return 0;
}

문제점: 포인터 타입이 Animal*이므로 컴파일 타임에 Animal::speak()가 호출됨

virtual 키워드로 해결

class Animal
{
public:
    virtual void speak()  // ✅ 가상 함수로 선언
    {
        std::cout << "Animal sound" << std::endl;
    }
};

class Cat : public Animal
{
public:
    void speak() override  // override 키워드 권장
    {
        std::cout << "Meow~" << std::endl;
    }
};

int main()
{
    Cat kitty;
    Animal* ptr = &kitty;

    ptr->speak();  // ✅ "Meow~" 출력 (런타임에 실제 타입 확인!)
    return 0;
}

Dynamic Binding (동적 바인딩)

• 가상 함수는 런타임에 실제 객체의 타입을 확인하여 호출
• 이를 통해 다형성(Polymorphism) 구현

🔸 Virtual Destructor (가상 소멸자)

❗ 중요: Base 클래스의 소멸자는 반드시 virtual로 선언해야 함

문제 상황

class Animal
{
public:
    Animal() { std::cout << "Animal constructor" << std::endl; }
    ~Animal() { std::cout << "Animal destructor" << std::endl; }  // ❌ 가상 소멸자가 아님
};

class Cat : public Animal
{
public:
    Cat() { std::cout << "Cat constructor" << std::endl; }
    ~Cat() { std::cout << "Cat destructor" << std::endl; }
};

int main()
{
    Animal* polyCat = new Cat();
    // 출력:
    // Animal constructor
    // Cat constructor

    delete polyCat;
    // 출력:
    // Animal destructor  ❌ Cat destructor가 호출되지 않음!
    // → 메모리 누수 발생!

    return 0;
}

해결: 가상 소멸자 사용

class Animal
{
public:
    Animal() { std::cout << "Animal constructor" << std::endl; }
    virtual ~Animal() { std::cout << "Animal destructor" << std::endl; }  // ✅ virtual 추가
};

class Cat : public Animal
{
public:
    Cat() { std::cout << "Cat constructor" << std::endl; }
    ~Cat() override { std::cout << "Cat destructor" << std::endl; }
};

int main()
{
    Animal* polyCat = new Cat();
    delete polyCat;
    // 출력:
    // Cat destructor    ✅ 올바른 순서로 호출됨
    // Animal destructor

    return 0;
}

가상 소멸자 규칙

• 상속받을 가능성이 있는 클래스의 소멸자는 반드시 virtual public으로 선언
• 또는 상속을 막으려면 소멸자를 protected로 선언

// ✅ 옵션 1: 상속 허용 + virtual 소멸자
class Base {
public:
    virtual ~Base() = default;
};

// ✅ 옵션 2: 상속 금지 (소멸자 protected)
class Base {
protected:
    ~Base() = default;  // 외부에서 delete 불가
};

// ✅ 옵션 3: C++11 final 키워드
class Base final {  // 상속 불가
public:
    ~Base() = default;
};

🔸 Virtual Table (가상 함수 테이블)

메모리 구조 변화

일반 함수만 있는 경우

class Animal
{
public:
    void speak() { std::cout << "Animal" << std::endl; }
private:
    double height;  // 8 bytes
};

class Cat : public Animal
{
public:
    void speak() { std::cout << "Meow~" << std::endl; }
private:
    double weight;  // 8 bytes
};

// sizeof(Animal) = 8 bytes  (height만)
// sizeof(Cat) = 16 bytes    (height + weight)

가상 함수가 있는 경우

class Animal
{
public:
    virtual void speak() { std::cout << "Animal" << std::endl; }
private:
    double height;  // 8 bytes
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }
private:
    double weight;  // 8 bytes
};

// sizeof(Animal) = 16 bytes  (vptr 8 + height 8)
// sizeof(Cat) = 24 bytes     (vptr 8 + height 8 + weight 8)

Virtual Table (VTable) 구조

Animal 객체 메모리:
┌─────────────┐
│ vptr (8B)  │ → Animal VTable
├─────────────┤   ┌──────────────────┐
│ height (8B)│   │&Animal::speak()│
└─────────────┘   └──────────────────┘

Cat 객체 메모리:
┌─────────────┐
│ vptr (8B)  │ → Cat VTable
├─────────────┤   ┌──────────────────┐
│ height (8B)│   │ &Cat::speak()  │
├─────────────┤   └──────────────────┘
│ weight (8B)│
└─────────────┘

Virtual Table의 동작 원리

1. 가상 함수가 있는 클래스는 vptr (virtual table pointer) 을 가짐 (8 bytes)
2. vptr은 해당 클래스의 VTable을 가리킴
3. VTable에는 가상 함수들의 실제 주소가 저장됨
4. 가상 함수 호출 시 vptr → VTable → 실제 함수 주소로 간접 호출

성능 고려사항

• 가상 함수가 없는 경우: 직접 호출 (빠름)
• 가상 함수가 있는 경우: 간접 호출 (약간 느림, 약 20-30% 오버헤드)
• 메모리: 객체당 vptr 8 bytes 추가

🔸 부모 클래스 포인터의 제약

class Animal
{
public:
    virtual void speak() { std::cout << "Animal" << std::endl; }
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }
    void meow() { std::cout << "Meow meow!" << std::endl; }  // Cat 전용 함수
};

int main()
{
    Cat kitty;
    Animal* ptr = &kitty;

    ptr->speak();  // ✅ OK - 가상 함수이므로 Cat::speak() 호출됨
    ptr->meow();   // ❌ 컴파일 에러! Animal 타입으로는 meow() 접근 불가

    // 해결 방법 1: Cat 타입 포인터 사용
    Cat* catPtr = &kitty;
    catPtr->meow();  // ✅ OK

    // 해결 방법 2: 다운캐스팅 (권장하지 않음)
    Cat* catPtr2 = static_cast<Cat*>(ptr);
    catPtr2->meow();  // ✅ OK (하지만 위험함)

    return 0;
}

핵심 원칙

• 부모 타입 포인터로는 부모 클래스에 선언된 멤버만 접근 가능
• 가상 함수는 런타임에 실제 타입의 함수가 호출되지만, 접근 가능 여부는 컴파일 타임에 결정됨
• 자식 클래스 전용 함수를 사용하려면 자식 타입 포인터를 사용해야 함

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

순수 가상 함수 선언

class Animal
{
public:
    virtual void speak() = 0;  // ✅ 순수 가상 함수
    // = 0 은 "구현이 없음"을 의미
};

Abstract Class (추상 클래스)

• 순수 가상 함수가 하나라도 있는 클래스를 추상 클래스라고 함
• 추상 클래스는 객체를 생성할 수 없음
• 추상 클래스를 상속받은 클래스는 모든 순수 가상 함수를 구현해야 객체 생성 가능

class Animal  // Abstract class
{
public:
    virtual void speak() = 0;  // 순수 가상 함수
    virtual void eat() { std::cout << "Eating" << std::endl; }  // 일반 가상 함수도 가능
    virtual ~Animal() = default;
};

class Cat : public Animal
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }  // ✅ 구현 필수
};

class Dog : public Animal
{
    // ❌ speak()를 구현하지 않음 → Dog도 추상 클래스가 됨
};

int main()
{
    Animal animal;  // ❌ 컴파일 에러! 추상 클래스는 객체 생성 불가
    Cat kitty;      // ✅ OK - speak()를 구현했으므로
    Dog puppy;      // ❌ 컴파일 에러! Dog도 추상 클래스

    Animal* ptr = new Cat();  // ✅ OK - 포인터는 가능
    ptr->speak();  // "Meow~"
    delete ptr;

    return 0;
}

🔸 Interface (인터페이스)

인터페이스 정의

• 순수 가상 함수만으로 이루어진 클래스
• 구현(implementation)과 멤버 변수가 없음
• 다른 언어(Java, C#)의 interface와 동일한 개념

// ✅ 좋은 인터페이스 설계
class IDrawable  // I 접두사는 인터페이스 표시 (관례)
{
public:
    virtual void draw() = 0;
    virtual void setColor(int r, int g, int b) = 0;
    virtual ~IDrawable() = default;  // 가상 소멸자는 필수

    // 멤버 변수 없음
    // 구현된 함수 없음
};

class Circle : public IDrawable
{
public:
    void draw() override { /* 원 그리기 구현 */ }
    void setColor(int r, int g, int b) override { /* 색상 설정 구현 */ }

private:
    double radius;
    int red, green, blue;
};

인터페이스 설계 원칙

1. 순수 가상 함수만 포함

   • 구현 코드 없음
   • 멤버 변수 없음

2. 가상 소멸자 필수

   virtual ~IDrawable() = default;

3. 복사/이동 방지 (권장)

   class IDrawable
   {
   public:
       virtual void draw() = 0;
       virtual ~IDrawable() = default;
   
   protected:
       IDrawable() = default;  // 생성자 protected
       IDrawable(const IDrawable&) = delete;  // 복사 금지
       IDrawable& operator=(const IDrawable&) = delete;
   };

인터페이스 사용의 장점

• 유지보수성 향상: 구현과 인터페이스 분리
• 의존성 감소: 구체적인 클래스 대신 인터페이스에 의존
• 테스트 용이: Mock 객체 생성 쉬움
• 플러그인 아키텍처: 런타임에 구현체 교체 가능

// 나쁜 설계: 구체 클래스에 의존
void processImage(JPEGImage& img) { /* ... */ }

// 좋은 설계: 인터페이스에 의존
void processImage(IImage& img) { /* ... */ }
// JPEG, PNG, BMP 등 다양한 구현체 사용 가능

실전 예제: 다중 인터페이스 구현

class ISerializable
{
public:
    virtual std::string serialize() = 0;
    virtual void deserialize(const std::string& data) = 0;
    virtual ~ISerializable() = default;
};

class ILoggable
{
public:
    virtual void log() = 0;
    virtual ~ILoggable() = default;
};

class User : public ISerializable, public ILoggable
{
public:
    std::string serialize() override { /* JSON 변환 */ }
    void deserialize(const std::string& data) override { /* JSON 파싱 */ }
    void log() override { /* 로그 출력 */ }

private:
    std::string name;
    int age;
};

🔸 핵심 정리

상속 사용 가이드라인

1. public 상속만 사용 (99%의 경우)
2. Base 클래스 소멸자는 virtual public 또는 protected
3. 다형성이 필요하면 virtual 함수 사용
4. 인터페이스는 순수 가상 함수만으로 구성
5. override 키워드로 의도 명확히 표현

// ✅ 올바른 상속 구조
class IAnimal  // 인터페이스
{
public:
    virtual void speak() = 0;
    virtual ~IAnimal() = default;
};

class Animal : public IAnimal  // 추상 클래스
{
public:
    void speak() override { std::cout << "Animal" << std::endl; }
    virtual ~Animal() = default;

protected:
    int age;  // 공통 데이터
};

class Cat final : public Animal  // 구체 클래스 (final로 더 이상 상속 금지)
{
public:
    void speak() override { std::cout << "Meow~" << std::endl; }
};

<참고 자료>

코드없는 프로그래밍 C++ Inheritance C++ Virtual Functions

🔸 Function/Operator Overloading

Function Overloading (함수 오버로딩)

• 같은 이름의 함수를 여러 개 정의
• 매개변수의 타입이나 개수가 달라야 함
• Name Mangling: 컴파일러가 함수 이름에 타입 정보를 추가하여 구분
• Static Polymorphism: 컴파일 타임에 어떤 함수를 호출할지 결정

void print(int x) { std::cout << "int: " << x << std::endl; }
void print(double x) { std::cout << "double: " << x << std::endl; }
void print(std::string x) { std::cout << "string: " << x << std::endl; }

int main()
{
    print(10);        // print(int) 호출
    print(3.14);      // print(double) 호출
    print("hello");   // print(std::string) 호출
    return 0;
}

Operator Overloading (연산자 오버로딩)

struct ComplexNum
{
    double real;
    double imag;

    ComplexNum(double r, double i) : real{r}, imag{i} {}

    void print() const
    {
        std::cout << real << " + " << imag << "i" << std::endl;
    }
};

// + 연산자 오버로딩 (전역 함수로 구현)
ComplexNum operator+(const ComplexNum& lhs, const ComplexNum& rhs)
{
    return ComplexNum{lhs.real + rhs.real, lhs.imag + rhs.imag};
}

int main()
{
    ComplexNum c1{1, 1};
    ComplexNum c2{1, 2};

    ComplexNum c3 = c1 + c2;  // operator+(c1, c2) 호출
    c3.print();  // 2 + 3i

    return 0;
}

멤버 함수 vs 전역 함수

// 멤버 함수로 구현
struct ComplexNum
{
    ComplexNum operator+(const ComplexNum& rhs) const
    {
        return ComplexNum{real + rhs.real, imag + rhs.imag};
    }
};
// c1 + c2 → c1.operator+(c2)

// 전역 함수로 구현
ComplexNum operator+(const ComplexNum& lhs, const ComplexNum& rhs)
{
    return ComplexNum{lhs.real + rhs.real, lhs.imag + rhs.imag};
}
// c1 + c2 → operator+(c1, c2)

전역 함수가 필요한 경우:

• 왼쪽 피연산자가 다른 타입일 때 (예: 2 * complex)
• 대칭적인 연산을 구현할 때

private 멤버 접근 문제:

• 전역 함수는 클래스의 private 멤버에 접근할 수 없음
• friend 키워드로 접근을 허용할 수 있지만, 캡슐화를 깨뜨리므로 권장하지 않음
• 대신 public getter 함수를 제공하거나 멤버를 public으로 만드는 것이 좋음 (간단한 구조체의 경우)

// ❌ friend 사용 (캡슐화 위반)
class ComplexNum {
    double real;
    double imag;
    friend ComplexNum operator+(const ComplexNum&, const ComplexNum&);
};

// ✅ public 멤버 또는 getter 사용
struct ComplexNum {
    double real;  // 간단한 데이터 구조는 public으로
    double imag;
};
// 또는
class ComplexNum {
    double real;
    double imag;
public:
    double getReal() const { return real; }
    double getImag() const { return imag; }
};

🔸 Class 관련 키워드

const (멤버 함수)

class Cat
{
    std::string mName;
    int mAge;

public:
    // const 멤버 함수: 객체의 상태를 변경하지 않음
    void print() const
    {
        std::cout << mName << " " << mAge << std::endl;
        // mAge = 10;  // ❌ 컴파일 에러!
    }

    std::string getName() const { return mName; }  // ✅ OK

    void setAge(int age) { mAge = age; }  // non-const 함수
};

int main()
{
    const Cat kitty{"kitty", 1};
    kitty.print();      // ✅ OK (const 함수)
    kitty.getName();    // ✅ OK (const 함수)
    kitty.setAge(2);    // ❌ 컴파일 에러! (non-const 함수)
    return 0;
}

mutable (가변 멤버 변수)

• const 멤버 함수 내에서도 수정 가능한 멤버 변수
• 주로 캐싱, 통계, 디버깅 정보 등에 사용
• 남용하면 const의 의미가 퇴색되므로 신중하게 사용

class Cat
{
    std::string mName;
    mutable int mCallCount;  // mutable 멤버

public:
    Cat(std::string name) : mName{std::move(name)}, mCallCount{0} {}

    std::string getName() const
    {
        mCallCount++;  // ✅ const 함수지만 수정 가능
        return mName;
    }

    int getCallCount() const { return mCallCount; }
};

int main()
{
    const Cat kitty{"kitty"};
    kitty.getName();
    kitty.getName();
    std::cout << kitty.getCallCount();  // 2
    return 0;
}

explicit (명시적 변환)

• 암묵적 타입 변환(Implicit Conversion)을 방지
• 주로 단일 매개변수 생성자에 사용

Implicit Conversion 문제 상황

class Cat
{
    int mAge;

public:
    Cat(int age) : mAge{age} {}  // 단일 매개변수 생성자
};

void func(Cat cat) { /* ... */ }

int main()
{
    Cat kitty = 3;      // ✅ Cat(3)으로 암묵적 변환
    func(5);            // ✅ Cat(5)로 암묵적 변환
    // 의도하지 않은 변환이 발생할 수 있음!
    return 0;
}

explicit으로 해결

class Cat
{
    int mAge;

public:
    explicit Cat(int age) : mAge{age} {}  // explicit 키워드
};

int main()
{
    Cat kitty = 3;      // ❌ 컴파일 에러!
    Cat kitty{3};       // ✅ OK (명시적 생성)
    Cat kitty(3);       // ✅ OK (명시적 생성)

    func(5);            // ❌ 컴파일 에러!
    func(Cat{5});       // ✅ OK (명시적 생성)

    return 0;
}

explicit 사용 가이드라인

• 단일 매개변수 생성자는 거의 항상 explicit을 붙이는 것이 좋음
• 의도적인 암묵적 변환이 필요한 경우만 생략 (예: wrapper 클래스)
• C++11부터는 여러 매개변수 생성자에도 사용 가능

class Vector
{
public:
    explicit Vector(int size) {}           // ✅ explicit 권장
    Vector(int x, int y, int z) {}         // 여러 매개변수는 선택적
    explicit Vector(std::vector<int> v) {} // ✅ explicit 권장
};

<참고 자료>

코드없는 프로그래밍 C++ Operator Overloading

🔸 Member Initializer List (멤버 초기화 리스트)

문제가 되는 코드

class Cat
{
public:
    Cat() { mAge = 1; }
    Cat(int age) { mAge = age; }
private:
    int mAge;
};

class Zoo
{
public:
    Zoo(int kittyAge) { mKitty = Cat(kittyAge); }  // ❌ 비효율적!
private:
    Cat mKitty;
};

int main()
{
    Zoo cppZoo(4);
    return 0;
}

문제점: 불필요한 임시 객체 생성

1. Zoo 생성자가 실행되기 전에 mKitty의 기본 생성자 Cat()가 먼저 호출됨
2. 생성자 본문에서 Cat(kittyAge)로 임시 객체를 생성
3. 임시 객체를 mKitty에 대입 (복사 또는 이동)
4. 임시 객체 소멸

→ 총 2번의 생성자 호출 + 1번의 대입 연산 발생

Member Initializer List로 해결

class Zoo
{
public:
    Zoo(int kittyAge) : mKitty{kittyAge} {}  // ✅ 효율적!
private:
    Cat mKitty;
};

장점:

• mKitty를 생성과 동시에 초기화
• 불필요한 기본 생성자 호출 제거
• 임시 객체 생성 없음
• 단 1번의 생성자 호출만 발생

Member Initializer List 사용 규칙

• () 대신 {}를 사용하면 더 안전 (narrowing conversion 방지)
• 멤버 변수 선언 순서대로 초기화됨 (초기화 리스트 순서와 무관)
• const 멤버 변수와 참조 멤버 변수는 반드시 초기화 리스트를 사용해야 함

class Example
{
public:
    Example(int a, int b, int c) 
        : mA{a}           // 멤버 변수
        , mB{b}           // 콤마로 구분
        , mC{c} {}        // 마지막도 콤마 가능

private:
    int mA;
    int mB;
    int mC;
};

🔸 Copy/Move Constructor & Assignment

기본 예제 코드

class Cat
{
public:
    Cat() = default;  // 기본 생성자는 컴파일러가 자동 생성

    Cat(std::string name, int age) 
        : mName{std::move(name)}
        , mAge{age}
    {
        std::cout << mName << " constructor" << std::endl;
    }

    ~Cat()
    {
        std::cout << mName << " destructor" << std::endl;
    }

    // Copy Constructor (복사 생성자)
    Cat(const Cat& other) 
        : mName{other.mName}
        , mAge{other.mAge}
    {
        std::cout << mName << " copy constructor" << std::endl;
    }

    // Move Constructor (이동 생성자)
    Cat(Cat&& other) noexcept
        : mName{std::move(other.mName)}
        , mAge{other.mAge}
    {
        std::cout << mName << " move constructor" << std::endl;
    }

    // Copy Assignment (복사 대입 연산자)
    Cat& operator=(const Cat& other)
    {
        if (&other == this) return *this;  // Self-assignment 체크

        mName = other.mName;
        mAge = other.mAge;
        std::cout << mName << " copy assignment" << std::endl;
        return *this;
    }

    // Move Assignment (이동 대입 연산자)
    Cat& operator=(Cat&& other) noexcept
    {
        if (&other == this) return *this;  // Self-assignment 체크

        mName = std::move(other.mName);
        mAge = other.mAge;
        std::cout << mName << " move assignment" << std::endl;
        return *this;
    }

    void print() const
    {
        std::cout << mName << " " << mAge << std::endl;
    }

private:
    std::string mName;
    int mAge;
};

사용 예제

int main()
{
    Cat kitty{"kitty", 1};              // 일반 생성자
    Cat kitty2{kitty};                  // 복사 생성자
    Cat kitty3{std::move(kitty)};       // 이동 생성자

    Cat bori{"bori", 1};
    Cat nabi{"nabi", 2};

    //bori = nabi;                        // 복사 대입 연산자
    bori = std::move(nabi);             // 이동 대입 연산자

    bori.print();  // nabi 2 (nabi의 데이터를 가져옴)
    nabi.print();  // (empty) 2 (mName이 이동되어 비어있음)

    return 0;
}

• 일반/복사/이동 생성자
• 복사/이동 대입 연산자

🔸 Self-Assignment 문제와 해결

Self-Assignment란?

Cat kitty{"kitty", 1};
kitty = kitty;              // 자기 자신을 대입
kitty = std::move(kitty);   // 자기 자신을 이동

문제 상황

• 기본 타입(int, string 등) 멤버만 있으면 큰 문제 없음
• 포인터 멤버 변수가 있으면 심각한 문제 발생 가능

class Cat
{
    std::string* mName;  // 포인터 멤버

public:
    Cat& operator=(const Cat& other)
    {
        delete mName;              // 1. 자신의 메모리 해제
        mName = new std::string(*other.mName);  // 2. other도 같은 객체면?
        // → 이미 해제된 메모리를 읽으려고 시도! (Undefined Behavior)
        return *this;
    }
};

해결 방법: Self-Assignment 체크

Cat& operator=(const Cat& other)
{
    if (&other == this) return *this;  // ✅ 자기 자신이면 바로 리턴

    mName = other.mName;
    mAge = other.mAge;
    std::cout << mName << " copy assignment" << std::endl;
    return *this;
}

Cat& operator=(Cat&& other) noexcept
{
    if (&other == this) return *this;  // ✅ 이동에서도 체크 필요

    mName = std::move(other.mName);
    mAge = other.mAge;
    std::cout << mName << " move assignment" << std::endl;
    return *this;
}

🔸 noexcept 키워드

noexcept를 붙여야 하는 함수

1. Destructor (소멸자)
2. Move Constructor (이동 생성자)
3. Move Assignment (이동 대입 연산자)

이유:

• 위 세 함수는 새로운 리소스를 요청하지 않음
• 따라서 메모리 할당 실패 등의 예외가 발생할 가능성이 없음
• noexcept를 명시하면 컴파일러가 더 효율적인 코드를 생성할 수 있음
• STL 컨테이너가 move semantics를 안전하게 사용할 수 있음

~Cat() noexcept {}  // 소멸자는 암묵적으로 noexcept이지만 명시 가능

Cat(Cat&& other) noexcept 
    : mName{std::move(other.mName)}
    , mAge{other.mAge} {}

Cat& operator=(Cat&& other) noexcept
{
    if (&other == this) return *this;
    mName = std::move(other.mName);
    mAge = other.mAge;
    return *this;
}

noexcept의 중요성

std::vector<Cat> cats;
cats.push_back(Cat{"kitty", 1});

// vector가 크기를 늘릴 때:
// - Move constructor가 noexcept면 → 이동 사용 (빠름)
// - noexcept가 없으면 → 복사 사용 (느림, 안전함)

🔸 특수 멤버 함수 제어

함수 사용 금지: = delete

class Cat
{
public:
    Cat(const Cat& other) = delete;  // 복사 생성자 사용 금지
    Cat& operator=(const Cat& other) = delete;  // 복사 대입 사용 금지
};

int main()
{
    Cat kitty{"kitty", 1};
    Cat kitty2{kitty};  // ❌ 컴파일 에러!
    return 0;
}

사용 사례:

• 복사하면 안 되는 리소스 관리 클래스 (파일 핸들, 뮤텍스 등)
• 싱글톤 패턴 구현
• 이동만 허용하고 복사는 금지하려는 경우

C++11 이전 방식

class Cat
{
private:
    Cat(const Cat& other);  // 선언만 하고 구현하지 않음
    Cat& operator=(const Cat& other);
    // private이므로 외부에서 호출 불가
    // 구현이 없으므로 클래스 내부에서도 링크 에러 발생
};

Rule of Zero/Three/Five

• Rule of Zero: 특수 멤버 함수를 하나도 정의하지 않음 (컴파일러에게 맡김)
• Rule of Three: 소멸자, 복사 생성자, 복사 대입 중 하나를 정의하면 나머지도 정의
• Rule of Five: 위 3개 + 이동 생성자 + 이동 대입 (C++11 이후)

<참고 자료>

코드없는 프로그래밍 C++ Constructors and Destructors

🔸 OOP - Class 소개

기본 개념

• Class : 객체를 만들기 위한 정의, 설계도, 틀
• Object : 클래스로부터 생성된 각각의 실체, 인스턴스

OOP의 4가지 핵심 특징

1. Abstraction (추상화)

   • 일반화(Generalization)와 모델링
   • 복잡한 현실 세계를 클래스로 단순화하여 표현

2. Encapsulation (캡슐화)

   • private 접근 지정자를 통해 구현
   • 데이터와 메서드를 하나로 묶고 외부로부터 보호

3. Inheritance (상속)

   • 기존 클래스의 특성을 물려받아 재사용
   • 코드의 재사용성과 확장성 향상

4. Polymorphism (다형성)

   • Static Polymorphism : Function Overloading (컴파일 타임에 결정)
   • Dynamic Polymorphism : Function Overriding (virtual 키워드 사용, 런타임에 결정)

🔸 Object Alignment (객체 메모리 정렬)

메모리 정렬 예제

class Cat
{
public:
    void Speak();
private:
    double d8;    // 8 bytes
    int i4a;      // 4 bytes
    int i4b;      // 4 bytes
};

메모리 크기 변화

• 위 코드의 경우: Cat 객체 크기 = 16 bytes

• d8과 i4a의 선언 순서를 바꾸면: 24 bytes로 증가

Padding이 발생하는 이유

• 메모리 정렬 규칙(Alignment Rule) 때문에 발생
• 각 멤버 변수는 자신의 크기의 배수인 주소에서 시작해야 함
  • int (4 bytes) : 0, 4, 8, 12, 16, ... 주소에서 시작
  • double (8 bytes) : 0, 8, 16, 24, 32, ... 주소에서 시작
• 전체 객체 크기는 가장 큰 멤버 변수 크기의 배수여야 함
• CPU가 정렬되지 않은 메모리에 접근할 때 성능이 저하되거나 오류가 발생할 수 있어 컴파일러가 자동으로 패딩을 삽입함

메모리 최적화 팁

• 구조체나 클래스 설계 시 멤버 변수를 크기 순으로 정렬하면 패딩을 최소화할 수 있음
• 큰 타입(double, long long)을 먼저, 작은 타입(char, bool)을 나중에 배치
• #pragma pack 지시자로 패딩을 제어할 수도 있지만, 성능 저하가 발생할 수 있으므로 주의 필요

🔸 alignas 키워드

False Sharing 문제

• Cat arr[100]과 같은 배열이 있을 때 발생 가능
• 캐시 라인(Cache Line)의 최소 단위는 64 bytes
• Cat 객체가 24 bytes인 경우, 하나의 객체가 두 개의 캐시 라인에 나뉘어 저장될 수 있음
• 이로 인해 false sharing이 발생하여 성능 저하 초래

alignas를 통한 해결

class alignas(32) Cat
{
    // ...
};

• 객체를 32 bytes 단위로 정렬하여 false sharing 방지
• 캐시 효율성 향상

🔸 Static in Class

1. Static Member Function (정적 멤버 함수)

• 객체를 생성하지 않고도 호출 가능
• 클래스 이름으로 직접 접근

  Cat::StaticSpeak();

2. Static Member Variable (정적 멤버 변수)

• 클래스 외부에서 명시적으로 초기화 필요

  class Cat {
      static int count;
  };
  int Cat::count = 0;  // 클래스 외부에서 초기화

• Static 메모리 영역(데이터 세그먼트)에 할당됨
• 모든 객체가 공유하는 변수
• 프로그램 시작 시 초기화되고 프로그램 종료 시까지 유지됨

3. Static Variable in a Function (함수 내 정적 변수)

• 함수 내부에서 선언된 정적 변수

  void func() {
      static int count = 0;  // 함수가 처음 호출될 때 초기화
      count++;
  }

• 함수가 처음 호출될 때 초기화됨
• 함수 호출이 끝나도 값이 유지됨

초기화 시점 비교

• Static member variable: 프로그램 시작 전 (전역 변수와 동일)
• Static variable in function: 함수가 처음 호출될 때 (지연 초기화)

🔸 this 키워드

this의 역할

• 현재 객체의 주소를 가리키는 포인터
• 멤버 함수 내에서 암묵적으로 사용됨

Static 멤버 함수의 제약

• Static 멤버 함수는 특정 객체와 연결되어 있지 않음
• 따라서 this 포인터가 존재하지 않음
• 일반 멤버 변수나 멤버 함수를 사용할 수 없음
  • 이들은 this를 통해 호출되기 때문

this 포인터 활용

• 멤버 변수와 매개변수 이름이 같을 때 구분

  void SetName(string name) {
      this->name = name;  // 멤버 변수와 매개변수 구분
  }

• 메서드 체이닝 구현

  Cat& SetAge(int age) {
      this->age = age;
      return *this;  // 자기 자신을 반환
  }

🔸 inline, const, constexpr 정리

inline 키워드

• 함수 호출 오버헤드를 제거하기 위한 키워드
• 컴파일러에게 함수 본문을 호출 지점에 직접 삽입하도록 요청
• 작고 자주 호출되는 함수에 사용하면 효과적
• 클래스 내부에서 정의된 멤버 함수는 자동으로 inline 처리됨
• 주의: 함수가 너무 크면 코드 크기가 증가할 수 있음 (컴파일러가 무시할 수 있음)

  inline int Add(int a, int b) { return a + b; }
  // 호출 시 → int result = a + b; 로 직접 삽입됨

const 키워드 (멤버 함수)

• 멤버 함수가 객체의 상태(멤버 변수)를 변경하지 않음을 명시
• const 객체는 const 멤버 함수만 호출할 수 있음
• 함수 선언 뒤에 const를 붙여 사용

  class Cat {
    int age;
  public:
    int GetAge() const { return age; }  // ✅ 읽기만 가능
    void SetAge(int a) { age = a; }     // ❌ const 객체는 호출 불가
  };
  

const Cat kitty; kitty.GetAge(); // ✅ OK kitty.SetAge(5); // ❌ 컴파일 에러

**constexpr 키워드**
- 컴파일 타임에 값이 결정되는 상수 표현식
- 런타임 성능 향상 (컴파일 시 계산 완료)
- 함수에 사용하면 컴파일 타임에 실행 가능
- C++11부터 도입, C++14/17에서 기능 확장
```cpp
constexpr int Square(int x) { return x * x; }

int arr[Square(5)];  // 컴파일 타임에 arr[25]로 결정됨

// static member variable과 함께 사용
class Math {
    static constexpr double PI = 3.14159;  // 컴파일 타임 상수
};

const vs constexpr 비교

• const: 런타임 또는 컴파일 타임 상수 (값 변경 불가)
• constexpr: 반드시 컴파일 타임 상수 (더 엄격함)

  const int a = 10;           // 컴파일 타임 상수
  const int b = GetValue();   // 런타임 상수 (함수 호출 결과)
  

constexpr int c = 10; // ✅ 컴파일 타임 상수 constexpr int d = GetValue(); // ❌ 컴파일 에러 (constexpr 함수여야 함)

```

<참고 자료>

코드없는 프로그래밍 C++ Classes and Objects

👨💻 오늘의 개발 작업

오늘은 게임 내 매뉴얼(설명서) UI 시스템을 구축했음 플레이 도중 Tab키를 누르면 QuickManual이 나오며, 현재 캐릭터의 스킬 조작법을 볼 수 있는 기능임

RTS와 TPS 두 가지 컨트롤러 모드가 있고, TPS 모드에서는 4개의 서로 다른 캐릭터(Seeker 3개 + Guardian 1개)가 있는 상황에서, 각 모드와 캐릭터마다 다른 매뉴얼 이미지를 보여줘야 했음

처음에는 if문으로 모든 케이스를 처리하려 했지만, 인터페이스를 도입하여 확장 가능하고 유지보수가 쉬운 구조로 개선했음

💡 오늘의 5분 기록

1. 데이터 테이블 구조 설계 및 이해

매뉴얼 데이터 구조체 정의

USTRUCT(BlueprintType)
struct FManualImageRow : public FTableRowBase
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Manual")
    uint8 PageIndex;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Manual")
    FText Title;

    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Manual")
    TSoftObjectPtr<UTexture2D> ManualImage;
};

데이터 테이블 구조 이해

RowName(키)    | PageIndex | Title      | ManualImage
---------------|-----------|------------|-------------
"Guardian"     | 1         | "가디언"    | Texture...
"Ares"         | 2         | "아레스"    | Texture...
"Chan"         | 3         | "찬"       | Texture...
"Merci"        | 4         | "머시"      | Texture...

데이터 접근 방법

// RowName으로 검색 (O(1), 빠름)
FManualImageRow* RowData = ManualImageTable->FindRow<FManualImageRow>(
    FName("Guardian"), 
    TEXT("InitImage")
);

if (RowData)
{
    UTexture2D* LoadedTexture = RowData->ManualImage.LoadSynchronous();
}

2. 초기 접근: if문 분기 처리의 한계

문제점 발견

// 각 컨트롤러/캐릭터마다 if문 필요
APlayerController* PC = GetOwningPlayer();
FName RowName;

if (ARTSController* RTSCtrl = Cast<ARTSController>(PC))
{
    RowName = FName("Guardian");
}
else if (ATPSController* TPSCtrl = Cast<ATPSController>(PC))
{
    APawn* Pawn = TPSCtrl->GetPawn();

    if (AAres* Ares = Cast<AAres>(Pawn))
        RowName = FName("Ares");
    else if (AChan* Chan = Cast<AChan>(Pawn))
        RowName = FName("Chan");
    else if (AMerci* Merci = Cast<AMerci>(Pawn))
        RowName = FName("Merci");
    else if (AGuardian* Guardian = Cast<ADrakhar>(Pawn))
        RowName = FName("Drakhar");
}

핵심 문제

• 새 캐릭터 추가 시 UI 코드 수정 필요
• 중복 코드 발생
• 유지보수성 저하

3. 설계 개선: 부모 클래스에 데이터 저장

캐릭터 상속 구조 파악

TPS Controller
├── Seeker (부모)
│   ├── Ares
│   ├── Chan
│   └── Merci
└── Guardian (부모)

부모 클래스에 RowName 저장

// Seeker.h
class ASeeker : public ACharacter
{
    GENERATED_BODY()

protected:
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Manual")
    FName ManualRowName;

public:
    FName GetManualRowName() const { return ManualRowName; }
};

// 자식 클래스 생성자에서 설정
AAres::AAres()
{
    ManualRowName = FName("Ares");
}

AChan::AChan()
{
    ManualRowName = FName("Chan");
}

Guardian도 동일하게 구현

4. 최종 해결책: 인터페이스 도입

인터페이스 정의

// IManualDataInterface.h
UINTERFACE(MinimalAPI, Blueprintable)
class UGS_ManualDataInterface : public UInterface
{
    GENERATED_BODY()
};

class IGS_ManualDataInterface
{
    GENERATED_BODY()

public:
    UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category = "Manual")
    FName GetManualRowName() const;
};

Seeker 클래스에 인터페이스 구현

// Seeker.h
#include "IGS_ManualDataInterface.h"  // 헤더 include 필수

class ASeeker : public ACharacter, public IGS_ManualDataInterface
{
    GENERATED_BODY()

protected:
    UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Manual")
    FName ManualRowName;

public:
    // 인터페이스 함수 구현
    virtual FName GetManualRowName_Implementation() const override
    {
        return ManualRowName;
    }
};

Guardian 클래스도 동일하게 구현

5. UI 로직 대폭 간소화

통합된 단순 처리

void UGS_QuickManualUI::InitImage()
{
    FName RowName;
    APlayerController* PC = GetOwningPlayer();

    // RTS 시점일 경우
    AGS_RTSController* RTSCtrl = Cast<AGS_RTSController>(PC);
    if (RTSCtrl)
    {
        RowName = FName("Guardian");
    }

    // TPS 시점일 경우 - 단 하나의 if문으로 처리!
    APawn* Pawn = PC->GetPawn();
    if (Pawn && Pawn->Implements<UGS_ManualDataInterface>())  // U 접두사 사용
    {
        RowName = IGS_ManualDataInterface::Execute_GetManualRowName(Pawn);  // I 접두사 사용
    }

    // 데이터 테이블에서 이미지 로드
    if (!RowName.IsNone())
    {
        FManualImageRow* RowData = ManualImageTable->FindRow<FManualImageRow>(
            RowName, 
            TEXT("InitImage")
        );

        if (RowData)
        {
            UTexture2D* LoadedTexture = RowData->ManualImage.LoadSynchronous();
            if (LoadedTexture)
            {
                KeyManualImage->SetBrushFromTexture(LoadedTexture);
            }
        }
    }
}

6. 트러블슈팅 - 인터페이스 사용 시 컴파일 에러 ⚠️

문제 발생

error: 'IGS_ManualDataInterface': no member 'StaticClass'
note: see reference to function template instantiation 
'bool UObject::Implements<IGS_ManualDataInterface>(void) const'

원인 분석 언리얼 인터페이스는 두 개의 클래스가 생성됨:

• U 접두사 (UGS_ManualDataInterface): 리플렉션 시스템용, UINTERFACE
• I 접두사 (IGS_ManualDataInterface): 실제 인터페이스, 함수 정의

해결 방법

// 잘못된 사용
if (Pawn->Implements<IGS_ManualDataInterface>())  // ❌ I 접두사 사용 불가

// 올바른 사용
if (Pawn->Implements<UGS_ManualDataInterface>())  // ✅ U 접두사 사용
{
    // 함수 호출 시에는 I 접두사 사용
    FName Name = IGS_ManualDataInterface::Execute_GetManualRowName(Pawn);
}

규칙 정리

1. Implements<> 체크: U 접두사 사용
2. Execute_ 함수 호출: I 접두사 사용
3. 상속 시: I 접두사 사용 (public IGS_ManualDataInterface)
4. 헤더 include: 상속 시 필수, 사용만 할 때는 cpp에서 include 가능

7. 성과와 개선 효과

코드 간소화

// 기존: 모든 캐릭터마다 if문 (20+ 줄)
if (AAres* Ares = Cast<AAres>(Pawn))
    RowName = FName("Ares");
else if (AChan* Chan = Cast<AChan>(Pawn))
    RowName = FName("Chan");
else if (AMerci* Merci = Cast<AMerci>(Pawn))
    RowName = FName("Merci");
else if (AGuardian* Guardian = Cast<AGuardian>(Pawn))
    RowName = FName("Guardian");

// 새로운: 단 하나의 if문 (3줄)
if (Pawn && Pawn->Implements<UGS_ManualDataInterface>())
{
    RowName = IGS_ManualDataInterface::Execute_GetManualRowName(Pawn);
}

개발자 경험 개선

• ✅ 확장성: 새 캐릭터 추가 시 UI 코드 수정 불필요
• ✅ 유지보수성: 각 캐릭터가 자신의 데이터를 관리
• ✅ 일관성: 모든 캐릭터를 동일한 방식으로 처리
• ✅ 타입 안전성: 인터페이스로 계약 보장

배운 교훈

• 데이터 테이블의 RowName은 고유 식별자로 FindRow()의 키 역할
• 인터페이스는 다형성을 제공하여 if문 분기를 제거
• 언리얼 인터페이스의 U/I 접두사 규칙 이해 필수

🔸 Pass by Value vs Pass by Pointer vs Pass by Reference

세 가지 전달 방식의 특징

• Pass by Value : 값을 복사해서 전달함. 원본 데이터는 변경되지 않음
• Pass by Pointer : 메모리 주소를 전달함. 포인터 연산이 가능하고, nullptr 체크가 필요함
• Pass by Reference : 참조를 통해 전달함. 포인터처럼 동작하지만 더 안전하고 편리함

성능 비교

• Pointer와 Reference는 어셈블리 수준에서 동일하게 동작함
• 큰 객체를 전달할 때는 복사 비용이 큰 Pass by Value보다 Reference나 Pointer를 사용하는 것이 효율적임
• 포인터가 꼭 필요한 상황(nullptr 체크, 포인터 연산 등)이 아니라면 Reference를 사용하는 것이 더 안전하고 편리함

🔸 L-value와 R-value

L-value (Left value)

• 메모리 상에 위치가 있어서 여러 번 참조할 수 있는 값
• 변수명으로 식별 가능한 객체
• 주소 연산자(&)를 사용할 수 있음
• 예시: int x = 10;에서 x는 L-value

R-value (Right value)

• 임시로 생성되어 표현식이 끝나면 사라지는 값
• 메모리 주소를 가질 수 없음
• 대입 연산자의 오른쪽에만 올 수 있음
• 예시: int x = 10;에서 10은 R-value, x + 5도 R-value

🔸 L-value Reference vs R-value Reference

L-value Reference (&)

• L-value를 참조하기 위한 방식
• 기존 변수를 참조할 때 사용
• 선언: string& ref = str;

R-value Reference (&&)

• R-value를 참조하기 위한 방식 (C++11부터 도입)
• 임시 객체나 이동 가능한 객체를 받을 때 사용
• Move semantics를 구현하기 위해 사용됨
• 주로 함수 매개변수로 활용: void func(string&& s)

Move Semantics란?

• 객체의 자원(메모리 등)을 복사하지 않고 이동시키는 최적화 기법
• 불필요한 복사를 줄여 성능을 향상시킴
• R-value reference를 통해 구현됨

🔸 예제 코드: 매개변수 전달 방식

void StoreByValue(string s)
{ 
    string b = s;
}
void StoreByLRef(string& s)
{ 
    string b = s; 
}
void StoreByRRef(string&& s)
{ 
    //string b = s;
    string b = std::move(s);
}
int main()
{
    string a = "abc";
    StoreByValue(a);
    StoreByLRef(a);
    StoreByRRef("abc");

    return 0;
}

🔸 std::move를 통한 복사 최적화

std::move의 역할

• L-value를 R-value로 캐스팅하여 move semantics를 활용할 수 있게 해줌
• 불필요한 복사를 제거하고 이동으로 대체하여 성능을 향상시킴
• 객체의 소유권을 이전할 때 사용함

예제 코드: std::move 활용

class Cat
{
    public:
        void SetName(string name)
        { 
            mName = std::move(name);
        }
    private:
        string mName;
};

int main()
{
    Cat kitty;
    string s = "kitty";
    kitty.SetName(s); // 1 copy
    kitty.SetName("nabi"); // 0 copy
}

복사 횟수 분석

• kitty.SetName(s) : L-value 전달 → 매개변수로 1 copy, std::move로 이동 → 총 1 copy
• kitty.SetName("nabi") : R-value 전달 → 매개변수로 이동, std::move로 이동 → 총 0 copy

🔸 RVO (Return Value Optimization)

RVO란?

• 컴파일러가 함수의 반환 과정에서 발생하는 불필요한 복사를 제거하는 최적화 기법
• C++17부터는 특정 조건에서 RVO가 의무화됨 (guaranteed copy elision)
• 반환 값을 임시 객체로 만들지 않고 직접 목적지에 생성함

예제 코드: RVO 적용

string getString()
{
    string s = "hello";
    return s;
}

int main()
{
    string a = getString();
    return 0;
}

동작 방식

• 반환할 때 1 copy가 이루어질 것 같지만, RVO의 개입으로 s는 만들어지지 않고 바로 a에 hello가 저장되어 0 copy가 가능함

RVO가 개입되지 않는 경우

string getString(string s)
{
    if(조건)
    {
        s = "hello";
    }
    return s;
}

• s에 바로 hello를 대입해도 되는지 모르는 상황이므로 RVO 개입이 불가능함
• 그래도 0 copy로 이루어지는데, 이는 move constructor 덕분임 (이건 나중에 정리)

NRVO (Named RVO)

• 이름이 있는 지역 변수를 반환할 때의 최적화
• 컴파일러가 보장하지 않으며, 조건에 따라 적용 여부가 달라짐
• 여러 반환 경로가 있거나 조건부 반환이 있으면 적용되지 않을 수 있음

🔸 사용 가이드라인

매개변수 전달 방식 선택

1. Pass by Value

   • 작은 타입(int, char 등)을 전달할 때
   • 복사본이 필요할 때

2. Pass by Const Reference (const T&)

   • 큰 객체를 읽기 전용으로 전달할 때
   • 가장 일반적으로 권장되는 방식

3. Pass by Reference (T&)

   • 함수 내에서 원본을 수정해야 할 때

4. Pass by R-value Reference (T&&)

   • Move semantics를 활용할 때
   • 임시 객체를 효율적으로 처리할 때
   • Perfect forwarding을 구현할 때

5. Pass by Pointer (T*)

   • nullptr 가능성이 있을 때
   • 포인터 연산이 필요할 때
   • C 라이브러리와 호환이 필요할 때

최적화 활용

• 멤버 변수에 값을 저장할 때는 std::move()를 사용하여 불필요한 복사를 줄일 수 있음
• 함수 반환 시에는 RVO를 믿고 단순하게 값을 반환하는 것이 좋음 (명시적으로 std::move를 사용하면 오히려 RVO를 방해할 수 있음)
• 복잡한 조건부 반환이 있는 경우에도 컴파일러가 move constructor를 활용하여 최적화를 수행함

<참고 자료>

코드없는 프로그래밍 C++ Reference와 Move Semantics

🔸 컴파일 과정

• 전처리기(Pre-processor) : #include, #define 같은 부분을 처리함
• 컴파일러(Compiler) : 코드 파일을 번역해 obj파일(translation unit)로 생성함
• 링커(Linker) : 각각의 translation unit을 연결해 실행파일을 생성함

🔸 링키지 과정 (Linkage Process)

• extern 키워드

  • 해당 식별자의 정의(심볼)가 현재 번역 단위 파일 바깥쪽에 있다고 링커에게 알려줌
  • 전역 함수, 변수는 기본적으로 extern 키워드가 붙었다고 간주됨

• static 키워드

  • 자신의 translation unit 안에서만 접근이 가능하게 만드는 키워드임
  • internal linkage 방법으로 unnamed namespace를 더 권장하는 듯

🔸 C와의 호환성

• extern "C" 키워드

  • C++ 소스에서 선언한 전역변수나 함수를 C에서 사용해야 할 경우 사용함
  • 이 키워드를 붙이면 네임 맹글링을 진행하지 않음
  • C 인터페이스를 가진 심볼로 생성됨 (함수 오버로딩도 불가능해짐)

  네임 맹글링(Name Mangling)

  • C++에서 지원하는 함수 오버로딩을 구현하기 위해 사용되는 심볼 작명 방식임
  • 컴파일 시 함수 이름을 고유하게 변경하여 같은 이름의 다른 함수들을 구분함

🔸 어셈블리 코드와 최적화

성능에 대한 오해

• multiply 연산보다 shift bit 연산이 더 빠르다고 알려져 있지만, 실제 어셈블리어로 변환해보면 똑같음 (최신 컴파일러에서는 최적화를 통해 비슷한 성능을 보이는 경우가 많음)
• 어셈블리어가 더 짧다고 더 빠른 것은 아님
• if/else문과 switch문도 똑같음
• 이런 이유들로 가독성이 좋은 코드를 선택하는 것이 좋음

🔸 디버깅과 최적화

디버그 옵션

• -g 옵션 : debug info가 포함됨
• debug info는 binary(machine code)와 cpp source를 연결해주는 디버깅용 메타 데이터임(소스 코드 줄 번호, 변수명, 타입 정보 등 포함)
• -o 옵션 : optimization을 진행함

🔸 라이브러리 종류

라이브러리 유형

• Header only : 헤더 파일만으로 구성됨
• Static library : 윈도우는 .lib / 리눅스는 .a 파일
• Dynamic library : 윈도우는 .dll / 리눅스는 .so 파일

🔹 Static Library

정의와 생성

• 오브젝트 파일을 모아서 하나의 아카이브 파일을 만듦
• 생성법: ar -rs libcat.a cat.o (cat.h에 대한 라이브러리 생성 시)

사용법

• g++ main.cpp -lcat으로 사용하지만 이렇게 하면 libcat.a파일이 표준 라이브러리 경로에 없어서 에러 발생함
• 해결법: -L 옵션을 붙여야 함 (특정 위치에서 libcat.a파일을 찾아서 적용)
• -L.이면 현재 디렉토리 위치를 의미함

🔹 Dynamic Library (Shared Library)

바인딩 타이밍

• Load time dynamic library : 로드 타임에 라이브러리가 바인딩됨
• Run time dynamic library : 런타임에 라이브러리가 바인딩됨
• Static은 exe파일이 만들어질 때 바인딩됨
• Run time은 특정 조건에서만 사용하고, 보통은 Load time을 씀

Load Time Dynamic Library 생성

g++ foo.cpp -fPIC -c
g++ -shared foo.o -o libfoo.so

-fPIC 옵션의 필요성

• shared library가 여러 어플리케이션, 프로세스에서 실행되어야 함
• -fPIC 옵션을 주지 않으면 absolute base address가 되어 서로 다른 앱에서 주소를 지정할 수 없음
• -fPIC 옵션을 주면 relative base address를 가져서 각각의 어플에서 로드되고 호출될 수 있음

Run Time Dynamic Library 사용 런타임에 동적으로 라이브러리를 로드하고 함수를 호출하는 코드를 작성할 수 있음. 이를 위해서는 <dlfcn.h> 헤더를 포함하고 dlopen, dlsym, dlclose 함수들을 사용하여 라이브러리를 동적으로 관리할 수 있음

#include <dlfcn.h>

int main()
{
    void* handle = dlopen("./libfoo.so", RTLD_LAZY);
    if(!handle)
    {
        //handle 없음 출력
    }
    void (*fooPtr)();
    fooPtr = (void(*)())dlsym(handle,"_Z3foov");

    (*fooPtr)();
    dlclose(handle);
    return 0;
}

<참고 자료>

코드없는 프로그래밍 [C/C++] extern, static

🔸 스택 메모리 (Stack Memory)

구조와 동작

• 함수 단위로 스택 프레임이 생성됨
• 함수 호출 시 스택에 쌓이고, 함수 종료 시 자동으로 제거됨
• 지역 변수, 매개 변수, 반환 주소, this 포인터(필요시)등이 포함됨

특징

• 객체가 스택에 할당될 때는 멤버 변수 공간만 할당됨
• 멤버 함수는 코드 영역에 저장되어 모든 객체가 같은 함수 주소를 공유함

🔸 힙 메모리 (Heap Memory)

C++에서의 사용법

• malloc, calloc 함수 사용 금지함 (객체 생성 불가능)
• new/delete 연산자를 사용함
• delete를 안 하면 메모리 누수가 발생함

메모리 누수 방지법

• 스마트 포인터 사용을 권장함
• 배열의 경우 vector 컨테이너를 사용함

⚖️ 성능 및 특성 비교

💡 힙 메모리의 장점

힙 메모리는 다음 세 가지 주요 문제를 해결함

1. Life Cycle - 함수 스코프를 벗어나도 데이터 유지함
2. Large Size - 스택 오버플로우 없이 대용량 데이터 처리함
3. Dynamic Allocation - 런타임에 필요한 만큼 메모리 할당함

< 참고 자료 >

코드없는 프로그래밍 힙 메모리에 대한 모든 것

오늘은 기존 무기 시스템의 Destroy/SpawnActor 방식을 오브젝트 풀링 방식으로 전면 리팩토링했음

기존 방식은 무기 교체 시마다 객체 생성/삭제로 인한 성능 오버헤드와 데이터 동기화의 복잡성 문제가 있었음

새로운 방식은 미리 생성된 무기 풀을 활용한 활성화/비활성화 전환으로 성능을 개선하고, 무기 상태의 지속적 유지를 통해 데이터 관리를 단순화하는 구조로 개선했음

💡 오늘의 5분 기록

1. 기존 무기 시스템의 문제점 분석 🔍

코드 리뷰 중에 무기 교체 시스템의 성능과 구조적 문제점들을 발견했음

기존 코드의 문제점

// ❌ 문제 1: 매번 객체 생성/삭제
void APlayerCharacter::EquipWeapon(EGunType GunType)
{
    if (CurrWeapon)
    {
        GunManager->UpdateGunData(CurrWeapon);  // 데이터 백업
        CurrWeapon->Destroy();                  // 객체 삭제
    }
    CurrWeapon = GetWorld()->SpawnActor<AGun>(GunClass); // 새 객체 생성
    GunManager->SetCurrentGun(CurrWeapon);      // 데이터 복원
}

// ❌ 문제 2: 이중 데이터 관리
TMap<EGunType, int32> OwnedGuns;  // 별도 데이터 저장
void UpdateGunData(AGun* CurrGun); // 무기 → 데이터 동기화
void SetCurrentGun(AGun* NextGun); // 데이터 → 무기 동기화

성능 영향 분석

• 무기 교체 시마다 메모리 할당/해제로 인한 프레임 드롭 가능성
• 가비지 컬렉션 압박 증가
• 데이터 동기화를 위한 추가 오버헤드

2. 오브젝트 풀링 전환 전략 수립 💡

핵심 아이디어 "미리 생성 + 활성화 전환 + 단일 데이터 소스"

설계 원칙 설정

성능: 객체 생성/삭제 → 활성화/비활성화
관리: 이중 데이터 → 무기 객체 단일 소스
구조: UObject → UActorComponent

예상 개선사항:

• 무기 교체 성능: 부드러운 전환
• 메모리 관리: 안정적인 사용량
• 코드 복잡도: 데이터 동기화 로직 제거

3. GunManager 구조 재설계 🛠️

1단계: 헤더 파일 개선

// 기존: 데이터만 관리
class UGunManager : public UActorComponent
{
    TMap<EGunType, int32> OwnedGuns;  // 데이터만 저장
};

// 개선: 객체 풀 관리
class UGunManager : public UActorComponent
{
    TMap<EGunType, AGun*> WeaponPool;    // 실제 무기 객체 풀
    TSet<EGunType> OwnedWeapons;         // 소유 무기 관리
};

2단계: 무기 풀 초기화 시스템

void UGunManager::BeginPlay()
{
    // 모든 무기 타입 미리 생성
    for (auto& WeaponPair : WeaponClasses)
    {
        AGun* WeaponInstance = World->SpawnActor<AGun>(GunClass);
        WeaponInstance->SetActorHiddenInGame(true);  // 비활성화
        WeaponPool.Add(GunType, WeaponInstance);
    }
}

4. 무기 교체 로직 개선 ⚡

기존 방식: 생성/삭제

// ❌ 비효율적: 매번 새 객체 생성
CurrWeapon->Destroy();
CurrWeapon = GetWorld()->SpawnActor<AGun>(GunClass);

개선된 방식: 활성화/비활성화

// ✅ 효율적: 풀에서 가져와서 활성화
if (CurrWeapon)
{
    CurrWeapon->SetActorHiddenInGame(true);     // 현재 무기 숨김
    CurrWeapon->DetachFromActor(...);
}

CurrWeapon = GunManager->GetWeapon(GunType);   // 풀에서 가져오기
CurrWeapon->SetActorHiddenInGame(false);       // 새 무기 표시
CurrWeapon->AttachToComponent(...);

5. 데이터 관리 단순화 📊

이중 관리 시스템 제거

// 기존: 무기 객체 + 별도 데이터 저장
TMap<EGunType, int32> OwnedGuns;              // 데이터 저장소
void UpdateGunData(AGun* Gun);                // 객체 → 데이터
void SetCurrentGun(AGun* Gun);                // 데이터 → 객체

// 개선: 무기 객체가 모든 상태 보유
TMap<EGunType, AGun*> WeaponPool;             // 객체 풀만 관리
AGun* GetWeapon(EGunType type);               // 직접 객체 반환

상태 유지 개선

• 탄약 수, 업그레이드, 커스터마이징 등 모든 무기 상태가 객체에 지속적으로 보존
• 데이터 동기화 과정에서 발생할 수 있는 상태 손실 위험 제거

6. PlayerCharacter 연동 최적화 🎯

BeginPlay 단순화

void APlayerCharacter::BeginPlay()
{
    Super::BeginPlay();
    // 컴포넌트가 자동으로 BeginPlay에서 풀 초기화 수행

    EquipWeapon(EGunType::PISTOL);  // 바로 장착 가능
}

7. 무기 획득 시스템 개선

AddItem 함수 최적화

void APlayerCharacter::AddItem(AItem* Item)
{
    AGun* Gun = Cast<AGun>(Item);
    if (Gun)
    {
        EGunType GunType = Gun->GetGunType();

        // 중복 확인 후 획득
        if (!GunManager->HasWeapon(GunType))
        {
            GunManager->AcquireWeapon(GunType);

            // 픽업한 무기 상태를 풀 무기에 복사
            AGun* PoolWeapon = GunManager->GetWeapon(GunType);
            PoolWeapon->SetCurrentAmmo(Gun->GetCurrentAmmo());
        }
    }
}

8. 최종 성능 개선 결과 📈

달성한 개선사항:

• ✅ 무기 교체 성능: Destroy/SpawnActor 제거로 부드러운 전환
• ✅ 메모리 안정성: 객체 생성/삭제 사이클 제거
• ✅ 상태 관리: 무기별 개별 상태 지속적 유지
• ✅ 코드 단순화: 데이터 동기화 로직 완전 제거

성능 벤치마크:

• 무기 교체 지연: 프레임 드롭 위험 → 즉시 전환
• 메모리 사용: 변동적 → 일정한 사용량
• 코드 복잡도: 높음 (동기화 로직) → 낮음 (직접 접근)

📚 개발 참고

언리얼 엔진 오브젝트 풀링 패턴

핵심 원칙:
1. 게임 시작 시 필요한 객체들을 미리 생성
2. 사용하지 않는 객체는 비활성화 상태로 대기
3. 필요할 때 활성화/비활성화로 재사용
4. 객체 자체에 모든 상태 정보 보존

UActorComponent vs UObject 선택 기준

UActorComponent 사용 시기:
- 특정 액터에 종속된 기능
- 라이프사이클 관리가 중요한 경우
- 블루프린트 접근성이 필요한 경우

UObject 사용 시기:
- 독립적인 데이터 구조체
- 여러 객체에서 공유되는 유틸리티
- 순수한 로직 처리 클래스

👨💻 오늘의 개발 작업

오늘은 구축한 프리셋 데이터 구조를 바탕으로 실제 UI에서 프리셋 전환이 동작하도록 구현했음

핵심적으로는 프리셋 버튼 클릭 시 저장확인 팝업 표시, 세이브 파일 호환성 문제 해결, 그리고 최근 사용 프리셋 자동 로드 기능을 완성했음

특히 기존 LoadBoardConfig() 함수가 너무 많은 책임을 가지고 있어서 발생했던 버그들을 함수 분리를 통해 근본적으로 해결했음

💡 오늘의 5분 기록

1. 프리셋 전환 시 저장확인 로직 구현

기존 문제점

• 프리셋 버튼 클릭 시 변경사항이 있어도 바로 전환됨
• 사용자가 실수로 작업한 내용을 잃을 수 있음

해결책: 팝업 기반 확인 시스템

// GS_ArcaneBoardWidget.h에 추가
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "ArcaneBoard")
TSubclassOf<class UGS_CommonTwoBtnPopup> PresetSaveConfirmPopupClass;

UPROPERTY()
int32 PendingPresetIndex; // 사용자가 선택한 대기 중인 프리셋

// 프리셋 버튼 함수들 수정
void UGS_ArcaneBoardWidget::OnPresetButton1Clicked()
{
    if (HasUnsavedChanges())
    {
        ShowPresetSaveConfirmPopup(1); // 저장확인 팝업 표시
    }
    else
    {
        SwitchToPreset(1); // 바로 전환
    }
}

팝업 응답 처리

void UGS_ArcaneBoardWidget::OnPresetSaveYes()
{
    // 현재 프리셋에 저장 후 새 프리셋으로 전환
    ArcaneBoardLPS->ApplyBoardChanges();
    SwitchToPreset(PendingPresetIndex);
}

void UGS_ArcaneBoardWidget::OnPresetSaveNo()
{
    // 저장하지 않고 바로 전환
    SwitchToPreset(PendingPresetIndex);
}

2. 세이브 파일 호환성 문제 해결

발생한 문제

LogClass: Warning: Struct Property SavedRunesByClass has a struct type mismatch 
(tag RunePlacementData(/Script/GAS) != prop ArcaneBoardPresets(/Script/GAS))

기존 RunePlacementData 구조체로 저장된 파일과 새로운 FArcaneBoardPresets 구조체 간의 타입 불일치

임시 해결: 기존 세이브 파일 삭제

• 개발 단계에서는 기존 파일 삭제로 빠른 해결
• 향후 버전 관리 시스템 도입 예정

새로운 문제 발견: 기본 룬 없음 세이브 파일 삭제 후 테스트용 룬이 없어서 기능 테스트 불가

기본 룬 시스템 도입

void UGS_ArcaneBoardLPS::InitializeDefaultRunes()
{
    OwnedRuneIDs.Empty();

    // 모든 플레이어가 기본 룬 2개로 시작
    OwnedRuneIDs.Add(1);
    OwnedRuneIDs.Add(2);

    UE_LOG(LogTemp, Log, TEXT("기본 룬 초기화 완료: 룬 ID 1, 2"));
}

3. LoadBoardConfig 함수 리팩토링

기존 함수의 문제점

• 단일 함수가 너무 많은 책임을 가짐
• 룬 인벤토리 초기화, 프리셋 로드, 보드 적용, 에러 처리 등 모든 것을 담당
• 디버깅이 어렵고 예외 케이스 처리가 복잡함

함수 분리를 통한 해결

// 1. 룬 인벤토리 초기화만 담당
void EnsureRuneInvenInit()
{
    if (OwnedRuneIDs.Num() > 0) return; // 이미 초기화됨

    // 세이브 파일에서 룬 데이터만 로드 시도
    // 실패 시 기본 룬으로 초기화
}

// 2. 프리셋 데이터 로드만 담당  
TArray<FPlacedRuneInfo> LoadPresetData(ECharacterClass CharClass, int32 PresetIndex)
{
    // 모든 예외 상황에서 빈 배열 반환
    // 크래시 방지를 위한 안전한 설계
}

// 3. 보드에 데이터 적용만 담당
void ApplyPresetToBoard(ECharacterClass CharClass, const TArray<FPlacedRuneInfo>& PresetData)
{
    BoardManager->LoadSavedData(CharClass, PresetData);
    BoardManager->bHasUnsavedChanges = false;
}

// 4. 전체 흐름 조율 (단순화된 메인 함수)
void LoadBoardConfig(int32 PresetIndex)
{
    EnsureRuneInvenInit();                       // 1단계
    TargetPresetIndex = DeterminePresetIndex(); // 2단계  
    PresetData = LoadPresetData();              // 3단계
    ApplyPresetToBoard(PresetData);             // 4단계
}

단일 책임 원칙(SRP) 적용 효과

• 각 함수가 명확한 하나의 책임만 가짐
• 디버깅 시 문제 구간을 쉽게 특정 가능
• 개별 기능을 독립적으로 테스트 가능
• 재사용성 향상

4. 최근 사용 프리셋 자동 로드 기능

기존 문제 아케인보드 창을 열면 항상 프리셋 1이 로드됨. 사용자가 프리셋 2에서 작업했어도 다음에 다시 프리셋 1부터 시작해야 함

GetLastUsedPresetIndex 함수 구현

int32 UGS_ArcaneBoardLPS::GetLastUsedPresetIndex()
{
    // 세이브 파일에서 LastUsedPresetIndex 값 읽기
    const FArcaneBoardPresets& ClassPresets = LoadedSaveGame->SavedRunesByClass[CurrClass];
    int32 LastUsedIndex = ClassPresets.LastUsedPresetIndex;

    if (LastUsedIndex >= 1 && LastUsedIndex <= 3)
    {
        return LastUsedIndex;
    }
    else
    {
        return 1; // 기본값
    }
}

LoadBoardConfig에서 최근 프리셋 우선 로드

void UGS_ArcaneBoardLPS::LoadBoardConfig(int32 PresetIndex)
{
    int32 TargetPresetIndex;
    if (PresetIndex == -1)
    {
        // 최근 사용 프리셋 로드
        TargetPresetIndex = GetLastUsedPresetIndex();
    }
    else
    {
        // 지정된 프리셋 로드
        TargetPresetIndex = PresetIndex;
    }
    // ...
}

Apply 시 최근 사용 프리셋 업데이트

void UGS_ArcaneBoardLPS::ApplyBoardChanges()
{
    BoardManager->ApplyChanges();

    // 현재 프리셋에 저장하면서 최근 사용 프리셋으로 기록
    SaveBoardConfig(CurrentPresetIndex);

    UE_LOG(LogTemp, Log, TEXT("변경사항을 프리셋 %d에 적용"), CurrentPresetIndex);
}