Reference

C++

참조, 클래스, STL, 자원 관리, 파일 I/O, modern utility type, 예외 안전성까지 C++의 핵심 흐름을 카드형 레퍼런스로 정리합니다.

전체44개

현재44개

레퍼런스 검색

시작과 문법

변수와 기본 타입

C++의 기본 타입 크기와 플랫폼 의존성, `auto` 타입 추론, `const`와 `constexpr`의 차이, 중괄호 초기화가 좁히기 변환을 막는 이유를 정리합니다.

#include <cstdint>
#include <string>

int main() {
    int count = 42;
    double ratio = 0.75;
    bool ready = true;
    std::int32_t id = 1001;        // 외부 형식이 32 bit를 요구할 때

    std::string name{"RefDock"};
    const double pi = 3.14159;    // 초기화 뒤 대입하지 않는다.
    constexpr int max_n = 100;    // 상수 평가가 필요한 값

    return ready && count < max_n && ratio < pi && id != 0 && !name.empty() ? 0 : 1;
}

참조와 const

참조가 포인터와 다른 점, `T&`·`const T&`·`T&&`의 기본 역할, 값 전달과 참조 전달이 어디서 갈리는지 정리합니다.

#include <iostream>
#include <string>

void print(const std::string& text) { std::cout << text << '\n'; }
void append(std::string& text, char suffix) { text += suffix; }

int main() {
    std::string name{"Mina"};
    std::string& alias = name;
    const std::string& view = name;
    append(alias, '!');
    print(view);
}

iostream 기본

`cout`·`cin`·`cerr`의 역할과 버퍼 동작, `getline`이 `>>` 이후에 빈 줄을 읽는 이유와 해결법, 출력 포맷(`setw`·`fixed`·`precision`)을 정리합니다.

#include <iostream>
#include <limits>
#include <string>

int main() {
    int count = 0;
    if (!(std::cin >> count)) {
        std::cerr << "정수를 입력하세요\n";
        return 1;
    }

    std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
    std::string title;
    std::getline(std::cin, title);
    std::cout << count << ": " << title << '\n';
}

네임스페이스와 using

네임스페이스가 이름 충돌을 막는 원리, `using namespace std`를 헤더에서 쓰면 안 되는 이유, `using` 선언으로 필요한 이름만 가져오는 패턴, 중첩 네임스페이스와 익명 네임스페이스를 정리합니다.

namespace myapp {
    void init() {}
    inline constexpr int version = 1;
}

int main() {
    myapp::init();
    using myapp::version;
    return version == 1 ? 0 : 1;
}

auto와 타입 추론

`auto`가 복사/참조/const를 어떻게 추론하는지, 어디까지 자동 추론에 맡기고 어디서 명시해야 하는지, `decltype`이 타입을 그대로 보존하는 방식을 정리합니다.

#include <string>
#include <vector>

auto count = 42;                    // int
auto ratio = 3.14;                  // double
auto name = std::string{"Mina"};    // std::string (값)

const std::string source{"RefDock"};
auto copy = source;                 // std::string: const와 참조가 빠진 값 복사
const auto& view = source;          // const std::string&: 원본을 읽기 전용으로 빌림

std::vector<int> values{1, 2, 3};
auto it = values.begin();           // 긴 iterator 타입을 추론

enum class 기본

이름 충돌과 암시적 정수 변환을 막는 `enum class`, 기저 타입 지정, `switch` 완전성 경고 활용, 문자열 변환 패턴을 정리합니다.

#include <iostream>

enum class Color { red, green, blue };
enum class State { idle, running, stopped };

int main() {
    Color color = Color::green;
    State state = State::running;

    // color == state;  // 컴파일 오류: 다른 enum class 타입
    (void)color;
    if (state == State::running) std::cout << "running\n";
}

중괄호 초기화

C++11의 중괄호 초기화 `{}`가 좁히기 변환을 막는 원리, 기본 타입·객체·컨테이너에 통일된 초기화 문법을 적용하는 방법, `initializer_list` 생성자와의 우선순위 충돌을 정리합니다.

#include <vector>

int count{10};
double ratio{0.75};
// int narrowed{3.14};       // narrowing이라 컴파일 오류

std::vector<int> values{3, 8};  // 원소 두 개: 3, 8
std::vector<int> repeated(3, 8); // 값 8을 세 개

file stream과 stringstream 기본

파일 읽기/쓰기 `ifstream`/`ofstream`, 문자열 파싱용 `stringstream`, 스트림 상태 확인 패턴, 줄 단위 파싱과 필드 분리를 정리합니다.

#include <fstream>
#include <iostream>
#include <sstream>
#include <string>

int main() {
    std::ifstream input{"scores.txt"};
    if (!input) return 1;

    std::string line;
    while (std::getline(input, line)) {
        std::istringstream fields{line};
        std::string name;
        int score = 0;
        if (fields >> name >> score) std::cout << name << ": " << score << '\n';
    }

    std::ofstream output{"result.txt"};
    if (!output) return 1;
    output << "Alice: 95\n";
}

포인터 기본

포인터 선언과 역참조, nullptr, 포인터 산술, 포인터와 참조의 차이, const 포인터 네 가지 조합을 정리합니다.

#include <iostream>

int main() {
    int value = 42;
    int* ptr = &value;      // 비소유 pointer

    if (ptr != nullptr) {
        std::cout << *ptr << '\n';
        *ptr = 100;         // 원본 value를 수정
    }
}

제어 흐름

조건문

`if`·`else if`·`else`와 C++17 `if` 초기화 문을 어디서 쓰는지, 단락 평가와 `=` vs `==` 같은 대표 실수를 함께 정리합니다.

#include <map>
#include <string>

int main() {
int score = 87;
char grade;
if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else {
    grade = 'C';
}

std::map<std::string, int> scores{{"Kim", 90}};
if (auto it = scores.find("Kim"); it != scores.end()) {
    grade = it->second >= 90 ? 'A' : 'B';
}
return grade == 'A' ? 0 : 1;
}

반복문

인덱스 기반 `for`, range-based `for`, `while`, `do-while`을 어디서 나누는지, 값 복사와 참조 순회 차이, 역방향 순회 함정을 정리합니다.

#include <cstddef>
#include <queue>
#include <vector>

int main() {
    std::vector<int> scores{90, 85, 100};
    for (std::size_t i = 0; i < scores.size(); ++i) {
        scores[i] += 1;                  // index가 필요할 때
    }

    for (const int score : scores) {     // 원소만 읽을 때
        (void)score;
    }

    std::queue<int> jobs;
    while (!jobs.empty()) {              // 종료 조건이 상태에 의존
        jobs.pop();
    }

    int attempts = 0;
    do { ++attempts; } while (attempts < 3); // 본문을 한 번 실행
}

switch와 case 스코프

이산 값 분기에 `switch`를 고르는 기준, fallthrough를 의도적으로 쓸 때의 패턴, case 안에서 지역 변수를 선언할 때 `{}`가 필요한 이유, `enum class`와 함께 쓰는 방법을 정리합니다.

#include <iostream>

enum class Mode { off, warmup, run };

int main() {
    Mode mode = Mode::warmup;

    switch (mode) {
    case Mode::off:
        std::cout << "off\n";
        break;
    case Mode::warmup: {
        int level = 1;
        std::cout << level << "\n";
        [[fallthrough]];        // C++17: 다음 case로 의도적으로 계속 실행
    }
    case Mode::run:
        std::cout << "running\n";
        break;
    }
}

범위 기반 for문

range-based for가 내부적으로 `begin()`/`end()` 반복자 쌍으로 전개되는 원리, `auto` vs `auto&` vs `const auto&` 선택 기준, 순회 중 컨테이너 수정이 위험한 이유를 정리합니다.

#include <iostream>
#include <map>
#include <string>
#include <vector>

int main() {
    std::vector<std::string> names{"Mina", "Jin", "Soo"};
    for (const auto& name : names) std::cout << name << ' '; // 복사 없이 읽기
    for (auto& name : names) name += '!';                    // 원본 수정

    std::map<std::string, int> scores{{"Mina", 100}};
    for (const auto& [name, score] : scores) std::cout << "\n" << name << '=' << score;
}

함수와 클래스

함수와 오버로딩

C++ 함수 오버로딩이 함수 시그니처로 해결되는 원리, 인자 타입에 따른 오버로드 선택 우선순위, 반환 타입만으로는 오버로딩이 안 되는 이유와 모호성 패턴을 정리합니다.

#include <iostream>
#include <string>

void print(int n) { std::cout << "int: " << n << "\n"; }
void print(double n) { std::cout << "double: " << n << "\n"; }
void print(const std::string& text) { std::cout << "str: " << text << "\n"; }

int main() {
    print(42);                    // int 버전
    print(3.14);                  // double 버전
    print(std::string{"hello"}); // string 버전
}

클래스와 객체

struct와 class의 차이, 멤버 변수·멤버 함수·접근 제어의 의미, 불변식을 지키기 위해 왜 class를 쓰는지, 기본 생성자 자동 생성 규칙을 정리합니다.

#include <iostream>

class Counter {
public:
    Counter() : count_{0} { }          // 기본 생성자

    void  increment()       { ++count_; }
    void  reset()           { count_ = 0; }
    int   value() const     { return count_; }  // const 멤버 함수

private:
    int count_;    // 외부에서 직접 접근 불가
};

int main() {
    Counter counter;
    counter.increment();
    std::cout << counter.value() << '\n';
}

생성자와 멤버 초기화 리스트

멤버 초기화 리스트가 생성자 본문 대입보다 효율적인 이유, `const`·참조 멤버가 초기화 리스트를 반드시 써야 하는 이유, 위임 생성자와 `= default`/`= delete` 패턴을 정리합니다.

#include <string>
#include <utility>

class Player {
public:
    Player(std::string name, int hp)
        : name_{std::move(name)}, hp_{hp}, alive_{true} { }

    Player() : Player{"Unknown", 100} { }

    int hp() const { return hp_; }
    bool alive() const { return alive_; }

private:
    std::string name_;
    int         hp_;
    bool        alive_;
};

기본 인자

기본 인자가 선언 위치(헤더)에서만 지정되어야 하는 이유, 오른쪽부터 기본값을 제공해야 하는 규칙, 오버로딩과 기본 인자의 관계를 정리합니다.

#include <iostream>
#include <string>

// 선언에서 한 번만 기본값을 지정한다.
void log(const std::string& msg,
         int level   = 0,
         bool flush  = false);

void log(const std::string& msg, int level, bool flush) {
    std::cout << '[' << level << "] " << msg << '\n';
    if (flush) std::cout << std::flush;
}

int main() {
    log("error", 2, true);  // 모든 인자 전달
    log("warning", 1);      // flush = false
    log("info");            // level = 0, flush = false
}

멤버 함수와 this 포인터

`this` 포인터가 암묵적으로 전달되는 원리, `const` 멤버 함수에서 `this`가 `const T*`가 되는 이유, 메서드 체이닝을 위한 `*this` 반환 패턴을 정리합니다.

#include <string>
#include <utility>

struct Server {
    std::string name;
    int port;
};

class Builder {
public:
    Builder& set_name(std::string n) {
        name_ = std::move(n);
        return *this;   // 메서드 체이닝
    }
    Builder& set_port(int p) { port_ = p; return *this; }

    Server build() const { return Server{name_, port_}; }

private:
    std::string name_;
    int         port_ = 8080;
};

int main() {
    Server server = Builder{}.set_name("localhost").set_port(9090).build();
    return server.port == 9090 ? 0 : 1;
}

헤더와 소스 파일 분리

선언을 헤더에, 구현을 소스 파일에 두는 이유(재컴파일 범위 최소화), `#pragma once` vs include guard, 헤더에 넣어야 하는 것과 넣으면 안 되는 것, ODR(One Definition Rule)을 정리합니다.

// user.h
#pragma once
#include <string>

class User {
public:
    explicit User(std::string name);
    void print() const;
    const std::string& getName() const;
private:
    std::string name_;
};

연산자 오버로딩 기본

연산자 오버로딩을 멤버 함수와 비멤버 함수로 구현하는 차이, `friend`로 비멤버 함수가 private에 접근하는 방법, 비교 연산자와 `<<` 오버로딩 패턴을 정리합니다.

#include <iostream>

class Vec2 {
public:
    double x = 0.0;
    double y = 0.0;

    Vec2& operator+=(const Vec2& other) {
        x += other.x;
        y += other.y;
        return *this;
    }
    friend Vec2 operator+(Vec2 left, const Vec2& right) { return left += right; }
    friend std::ostream& operator<<(std::ostream& output, const Vec2& value) {
        return output << '(' << value.x << ", " << value.y << ')';
    }
};

int main() { std::cout << (Vec2{1.0, 2.0} + Vec2{3.0, 4.0}) << '\n'; }

객체지향

상속과 virtual 함수

상속과 가상 함수의 동적 디스패치, `virtual` 없이 오버라이드하면 정적 바인딩이 되는 이유, `override`·`final` 키워드의 역할을 정리합니다.

#include <iostream>
#include <memory>
#include <string>
#include <utility>

class Shape {
public:
    virtual double area() const = 0;
    virtual std::string name() const { return "Shape"; }
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    explicit Circle(double radius) : radius_{radius} {}
    double area() const override { return 3.14159 * radius_ * radius_; }
    std::string name() const override { return "Circle"; }
private:
    double radius_;
};

int main() {
    std::unique_ptr<Shape> shape = std::make_unique<Circle>(5.0);
    std::cout << shape->name() << ": " << shape->area() << '\n';
}

접근 제어와 static 멤버

`public`·`protected`·`private`의 상속과의 관계, `static` 멤버가 클래스 인스턴스 없이 공유되는 원리, `static` 멤버 함수의 제약과 싱글턴 패턴을 정리합니다.

class Counter {
public:
    Counter()  { ++total_; }
    ~Counter() { --total_; }
    int id() const { return id_; }

    static int total() { return total_; }   // 인스턴스 없이 호출

private:
    int id_ = ++next_id_;
    inline static int total_ = 0;
    inline static int next_id_ = 0;
};

int main() {
    Counter first;
    Counter second;
    return Counter::total() == 2 ? 0 : 1;
}

추상 클래스와 override

순수 가상 함수로 인터페이스를 정의하는 추상 클래스의 역할, `override`·`final`로 오버라이드를 컴파일 타임에 검증하는 방법, 인터페이스 분리 원칙을 정리합니다.

#include <iostream>
#include <memory>
#include <string>
#include <utility>

class Serializable {
public:
    virtual std::string serialize() const = 0;
    virtual ~Serializable() = default;
};

class User final : public Serializable {
public:
    explicit User(std::string name) : name_{std::move(name)} {}
    std::string serialize() const override { return "user:" + name_; }
private:
    std::string name_;
};

int main() {
    std::unique_ptr<Serializable> value = std::make_unique<User>("mina");
    std::cout << value->serialize() << '\n';
}

virtual destructor와 object slicing

다형성을 쓰는 기반 클래스에서 `virtual ~Base()` 없이 `delete`할 때의 정의되지 않은 동작, 파생 객체를 기반 클래스 값으로 복사할 때 발생하는 object slicing을 정리합니다.

#include <iostream>
#include <memory>
#include <string>

class Animal {
public:
    virtual ~Animal() = default;
    virtual void speak() const = 0;
};

class Dog : public Animal {
public:
    void speak() const override { std::cout << "Woof\n"; }
    ~Dog() override { std::cout << "Dog destroyed\n"; }
};

int main() {
    std::unique_ptr<Animal> animal = std::make_unique<Dog>();
    animal->speak();
}

STL과 알고리즘

vector와 string 기본

`std::vector`와 `std::string`을 기본 컨테이너처럼 읽는 법, `reserve`와 재할당, `push_back`과 `emplace_back`, 인덱스 접근과 경계 차이를 정리합니다.

#include <iostream>
#include <string>
#include <vector>

int main() {
    std::vector<int> values;
    values.reserve(4);
    values.push_back(1);
    values.emplace_back(2);

    std::string text{"Hello"};
    text += ", World";
    std::cout << values.at(1) << ", " << text.substr(0, 5) << '\n';
}

map과 unordered_map

레드-블랙 트리 기반 `map`과 해시 테이블 기반 `unordered_map`의 성능 차이, `[]`와 `find`의 차이, `insert_or_assign`·`try_emplace`의 효율적인 삽입 패턴을 정리합니다.

#include <iostream>
#include <map>
#include <string>
#include <unordered_map>

int main() {
    std::map<std::string, int> scores{{"Alice", 95}, {"Bob", 88}};
    std::unordered_map<char, int> frequency;
    for (char letter : std::string{"banana"}) ++frequency[letter];

    if (const auto it = scores.find("Alice"); it != scores.end()) {
        std::cout << it->first << ": " << it->second << '\n';
    }
    std::cout << "a: " << frequency['a'] << '\n';
}

알고리즘 라이브러리

`<algorithm>`의 핵심 함수들 — 정렬, 탐색, 변환, 집계, 조건 검사 — 을 반복자 범위와 람다 조합으로 활용하는 방법을 정리합니다.

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> values{7, 2, 9, 4, 1};
    std::sort(values.begin(), values.end());
    std::sort(values.begin(), values.end(), std::greater<int>{});

    const auto exact = std::find(values.begin(), values.end(), 4);
    const auto firstLarge = std::find_if(
        values.begin(), values.end(), [](int value) { return value > 5; });

    if (exact != values.end()) std::cout << *exact << '\n';
    if (firstLarge != values.end()) std::cout << *firstLarge << '\n';
}

반복자 기본

반복자가 포인터를 추상화하여 알고리즘과 컨테이너를 분리하는 원리, 5가지 반복자 카테고리와 선택 기준, 무효화로 인한 정의되지 않은 동작 패턴을 정리합니다.

#include <algorithm>
#include <iostream>
#include <vector>

int main() {
    std::vector<int> values{1, 2, 3, 4, 5};
    for (auto it = values.begin(); it != values.end(); ++it) std::cout << *it << ' ';

    if (const auto found = std::find(values.begin(), values.end(), 3);
        found != values.end()) {
        std::cout << "\nfound: " << *found << '\n';
    }

    for (auto it = values.rbegin(); it != values.rend(); ++it) std::cout << *it << ' ';
}

set과 unordered_set

중복 없는 원소 집합인 `set`(정렬, O(log n))과 `unordered_set`(해시, O(1) 평균)의 차이, 존재 확인·삽입·삭제 패턴, 사용자 정의 타입에 해시 함수를 제공하는 방법을 정리합니다.

#include <iostream>
#include <set>
#include <string>
#include <unordered_set>

int main() {
    std::set<int> ordered{3, 1, 4, 1, 5};
    std::unordered_set<std::string> words{"hello"};
    ordered.insert(2);

    const bool hasFour = ordered.find(4) != ordered.end();
    const bool hasHello = words.count("hello") != 0;
    std::cout << hasFour << ' ' << hasHello << '\n';
}

stack, queue, priority_queue

컨테이너 어댑터 `stack`(LIFO), `queue`(FIFO), `priority_queue`(최댓값 우선)의 내부 컨테이너 구조, 핵심 API 차이, 최솟값 우선 큐 패턴을 정리합니다.

#include <iostream>
#include <queue>
#include <stack>

int main() {
    std::stack<int> stack; stack.push(10); stack.push(20); stack.pop();
    std::queue<int> queue; queue.push(1); queue.push(2); queue.pop();
    std::priority_queue<int> priority; priority.push(5); priority.push(1); priority.push(9);

    std::cout << stack.top() << ' ' << queue.front() << ' ' << priority.top() << '\n';
}

메모리와 자원 관리

스마트 포인터와 RAII

자원 수명을 객체 수명에 연결하는 RAII 원칙, `unique_ptr`(단독 소유)와 `shared_ptr`(공유 소유)의 차이, `make_unique`/`make_shared` 사용 이유, 순환 참조 해결을 위한 `weak_ptr`을 정리합니다.

#include <iostream>
#include <memory>
#include <string>
#include <utility>

struct User { explicit User(std::string value) : name{std::move(value)} {} std::string name; };

int main() {
    auto owner = std::make_unique<User>("Mina");
    auto shared = std::make_shared<User>("Jin");
    std::weak_ptr<User> observer = shared;

    if (auto value = observer.lock()) std::cout << owner->name << ", " << value->name << '\n';
}

move semantics 기본

lvalue/rvalue 구분, `std::move`가 실제로 하는 일(캐스팅), 이동 생성자·이동 대입 연산자 구현 패턴, 이동 후 원본 객체 상태를 정리합니다.

#include <iostream>
#include <string>
#include <utility>
#include <vector>

int main() {
    std::string source{"hello"};
    std::string target{std::move(source)};  // target이 내부 자원을 가져갈 수 있음

    std::vector<std::string> words;
    words.push_back(std::move(target));     // target 값은 이후에 가정하지 않음
    std::cout << words.front() << '\n';
}

복사 의미론과 특수 멤버 함수

컴파일러가 자동 생성하는 6개 특수 멤버 함수, 3의 규칙(Rule of Three)이 필요한 이유, 얕은 복사가 이중 해제를 일으키는 원리, `= default`/`= delete`로 의도를 명확히 하는 방법을 정리합니다.

#include <algorithm>
#include <cstddef>
#include <utility>

class Buffer {
public:
    explicit Buffer(std::size_t size) : data_{new int[size]}, size_{size} {}
    Buffer(const Buffer& other) : Buffer(other.size_) {
        std::copy(other.data_, other.data_ + size_, data_);
    }
    Buffer& operator=(Buffer other) noexcept {
        swap(other);
        return *this;
    }
    ~Buffer() { delete[] data_; }

    void swap(Buffer& other) noexcept {
        using std::swap;
        swap(data_, other.data_);
        swap(size_, other.size_);
    }
private:
    int* data_ = nullptr;
    std::size_t size_ = 0;
};

exception safety와 noexcept

예외가 발생해도 객체 상태와 자원이 보존되는 basic/strong/nothrow 보장 수준, `noexcept`가 이동 연산 성능에 미치는 영향, `noexcept` 잘못 사용 시 `std::terminate`로 이어지는 이유를 정리합니다.

#include <cstddef>
#include <memory>
#include <utility>

class Buffer {
public:
    Buffer() = default;
    Buffer(Buffer&& other) noexcept
        : data_{std::move(other.data_)}, size_{other.size_} {
        other.size_ = 0;
    }
    Buffer& operator=(Buffer&& other) noexcept {
        data_ = std::move(other.data_);
        size_ = std::exchange(other.size_, 0);
        return *this;
    }
private:
    std::unique_ptr<int[]> data_;
    std::size_t size_ = 0;
};

동적 메모리 기본

`new`와 `delete`로 힙 메모리를 수동 관리하는 방법과 그 위험성, 그리고 스마트 포인터로 전환해야 하는 이유를 정리합니다.

#include <memory>
#include <vector>

int main() {
    auto value = std::make_unique<int>(42);       // 단일 객체 소유
    std::vector<int> values{1, 2, 3, 4, 5};       // 가변 길이 배열

    int* raw = new int{7};                         // 직접 소유: 같은 스코프에서 해제
    delete raw;
    raw = nullptr;                                 // 이 포인터의 재사용 방지; 다른 alias는 여전히 dangling

    return *value + values.front();
}

현대 C++

lambda 표현식

lambda 문법 전체 — 캡처 모드 5가지, mutable, 반환 타입 지정, 제네릭 lambda, STL 알고리즘과의 조합까지 정리합니다.

#include <iostream>
#include <string>

int main() {
    int factor = 2;
    auto square = [](int value) { return value * value; };       // 캡처 없음
    auto scale = [factor](int value) { return value * factor; }; // 값 캡처

    std::string title{"RefDock"};
    auto rename = [&title](const std::string& suffix) { title += suffix; }; // 참조 캡처
    rename(" C++");

    std::cout << square(5) << ", " << scale(3) << ", " << title << '\n';
}

템플릿 기본

함수 템플릿과 클래스 템플릿으로 타입에 독립적인 코드를 작성하는 방법, 명시적 특수화, typename과 class 키워드 차이를 정리합니다.

#include <iostream>
#include <string>
#include <utility>

template <typename T>
T maxOf(T left, T right) { return left > right ? left : right; }

template <typename T>
class Box {
public:
    explicit Box(T value) : value_{std::move(value)} {}
    const T& get() const { return value_; }
private:
    T value_;
};

int main() {
    Box<std::string> title{"RefDock"};
    std::cout << maxOf(10, 20) << ", " << title.get() << '\n';
}

structured bindings와 pair

C++17 structured bindings로 pair·tuple·배열·구조체를 분해하는 문법, `auto` vs `auto&` vs `const auto&` 선택 기준, map 순회 패턴을 정리합니다.

#include <iostream>
#include <map>
#include <string>
#include <tuple>

int main() {
    std::pair<std::string, int> entry{"apple", 3};
    auto [name, count] = entry;              // 값 복사
    auto& [original_name, original_count] = entry;
    original_count += 1;                     // entry.second를 수정

    std::map<std::string, int> scores{{"Kim", 90}, {"Lee", 85}};
    for (const auto& [key, value] : scores) {
        std::cout << key << ": " << value << "\n";
    }
}

예외 처리 기본

오류를 호출 체인 위로 전달하는 `throw`/`try`/`catch` 동작 원리, 스택 언와인딩과 RAII의 관계, 표준 예외 계층 구조, 예외를 써야 할 때와 쓰지 말아야 할 때를 정리합니다.

#include <iostream>
#include <stdexcept>

int divide(int a, int b) {
    if (b == 0) throw std::invalid_argument("division by zero");
    return a / b;
}

int main() {
    try {
        std::cout << divide(10, 0) << '\n';
    } catch (const std::invalid_argument& error) {
        std::cerr << error.what() << '\n';
    } catch (const std::exception& error) {
        std::cerr << "오류: " << error.what() << '\n';
    }
}

std::optional 기본

값이 있을 수도 없을 수도 있는 상태를 타입 수준에서 표현하는 `std::optional`의 생성·확인·접근 패턴, `value_or`·`and_then` 체이닝, sentinel 값 방식과의 비교를 정리합니다.

#include <iostream>
#include <optional>

std::optional<int> findScore(bool found) {
    return found ? std::optional<int>{100} : std::nullopt;
}

int main() {
    const auto score = findScore(true);
    if (score) std::cout << *score << '\n';
    std::cout << findScore(false).value_or(0) << '\n';
}

string_view와 span 기본

소유권 없이 문자열과 연속 메모리를 바라보는 `std::string_view`와 `std::span`의 복사 비용 제거 원리, `const std::string&`과의 차이, dangling view 방지 패턴을 정리합니다.

#include <iostream>
#include <span>        // C++20
#include <string_view>
#include <vector>

void printName(std::string_view name) { std::cout << name << '\n'; }
int sumScores(std::span<const int> scores) {
    int sum = 0;
    for (int score : scores) sum += score;
    return sum;
}

int main() {
    std::vector<int> scores{1, 2, 3};
    printName("Alice");
    std::cout << sumScores(scores) << '\n';
}

variant와 visit 기본

`union`보다 타입 안전한 `std::variant`, 현재 타입에 따라 분기하는 `std::visit`, `get`/`get_if` 접근 패턴, 상속 계층과 비교 선택 기준을 정리합니다.

#include <iostream>
#include <string>
#include <variant>

int main() {
    std::variant<int, double, std::string> value{42};
    value = std::string{"hello"};

    if (const auto* text = std::get_if<std::string>(&value)) std::cout << *text << '\n';
    std::visit([](const auto& item) { std::cout << item << '\n'; }, value);
}

스레드와 동시성 기본

`std::thread`로 스레드를 생성하고, `mutex`와 `lock_guard`로 공유 데이터를 보호하는 C++ 동시성의 핵심 패턴을 정리합니다.

#include <iostream>
#include <mutex>
#include <thread>

std::mutex mutex;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock{mutex};
    ++counter;
}

int main() {
    std::thread first{increment};
    std::thread second{increment};
    first.join();
    second.join();
    std::cout << counter << '\n';
}

파일 시스템 기본

C++17 `std::filesystem`으로 경로 다루기, 파일/디렉토리 조작, 존재 여부 확인, 디렉토리 순회까지 정리합니다.

#include <filesystem>
#include <iostream>
#include <system_error>

namespace fs = std::filesystem;

int main() {
    const fs::path path = fs::path{"data"} / "config.json";
    std::error_code error;
    const auto size = fs::file_size(path, error);

    if (error) {
        std::cerr << path << ": " << error.message() << '\n';
        return 1;
    }
    std::cout << size << " bytes\n";
}

Loading category cards

Preparing references and filters for this topic. 이 주제의 레퍼런스와 필터를 준비하고 있습니다.