Category
Preparing references and filters for this topic. 이 주제의 레퍼런스와 필터를 준비하고 있습니다.
Category Reference
참조, 클래스, STL, 자원 관리, 파일 I/O, modern utility type, 예외 안전성까지 C++의 핵심 흐름을 카드형 레퍼런스로 정리합니다.
Search titles, summaries, tags, and subcategories.
Showing 44 cards.
Subcategory
9 cards
C++의 기본 타입 크기와 플랫폼 의존성, `auto` 타입 추론, `const`와 `constexpr`의 차이, 중괄호 초기화가 좁히기 변환을 막는 이유를 정리합니다.
int count = 42;
double ratio = 0.75;
bool ready = true;
std::int32_t id = 1001; // 크기 고정 타입
auto name = std::string{"RefDock"}; // 우변에서 타입 추론
const auto pi = 3.14159; // const 추론
constexpr int MAX_N = 100; // 컴파일 타임 상수참조가 포인터와 다른 점, `T&`·`const T&`·`T&&`의 기본 역할, 값 전달과 참조 전달이 어디서 갈리는지 정리합니다.
std::string name = "Mina";
std::string& alias = name; // 수정 가능한 참조
const std::string& view = name; // 읽기 전용 참조
void print(const std::string& s); // 복사 없이 읽기
void append(std::string& s, char c); // 원본 수정`cout`·`cin`·`cerr`의 역할과 버퍼 동작, `getline`이 `>>` 이후에 빈 줄을 읽는 이유와 해결법, 출력 포맷(`setw`·`fixed`·`precision`)을 정리합니다.
#include <iostream>
#include <string>
std::cout << "값: " << 42 << "\n"; // 출력
std::cerr << "에러 발생\n"; // 에러 출력 (버퍼 없음)
int n;
std::cin >> n; // 정수 입력
std::string line;
std::getline(std::cin, line); // 줄 전체 입력네임스페이스가 이름 충돌을 막는 원리, `using namespace std`를 헤더에서 쓰면 안 되는 이유, `using` 선언으로 필요한 이름만 가져오는 패턴, 중첩 네임스페이스와 익명 네임스페이스를 정리합니다.
namespace myapp {
void init() { }
int version = 1;
}
myapp::init(); // 완전한 이름(qualified name)
using myapp::init; // 특정 이름만 가져오기
init(); // 이제 init() 직접 사용 가능`auto`가 복사/참조/const를 어떻게 추론하는지, 어디까지 자동 추론에 맡기고 어디서 명시해야 하는지, `decltype`이 타입을 그대로 보존하는 방식을 정리합니다.
auto count = 42; // int
auto ratio = 3.14; // double
auto name = std::string{"Mina"}; // std::string (복사)
auto& ref = name; // std::string& (참조)
const auto& view = name; // const std::string& (읽기 전용)
auto it = vec.begin(); // std::vector<int>::iterator — 긴 타입 생략이름 충돌과 암시적 정수 변환을 막는 `enum class`, 기저 타입 지정, `switch` 완전성 경고 활용, 문자열 변환 패턴을 정리합니다.
enum class Color { red, green, blue };
enum class State { idle, running, stopped };
Color c = Color::green;
State s = State::running;
// c == s; // ❌ 컴파일 오류 — 다른 타입 비교 불가
if (s == State::running) std::cout << "running\n";C++11의 중괄호 초기화 `{}`가 좁히기 변환을 막는 원리, 기본 타입·객체·컨테이너에 통일된 초기화 문법을 적용하는 방법, `initializer_list` 생성자와의 우선순위 충돌을 정리합니다.
int count{10};
double ratio{0.75};
std::string name{"Mina"};
std::vector<int> scores{90, 85, 100};
std::pair<int, std::string> entry{1, "first"};
struct Point { int x; int y; };
Point p{3, 4};파일 읽기/쓰기 `ifstream`/`ofstream`, 문자열 파싱용 `stringstream`, 스트림 상태 확인 패턴, 줄 단위 파싱과 필드 분리를 정리합니다.
#include <fstream>
#include <sstream>
#include <string>
// 파일 읽기 — 줄 단위
std::ifstream file("scores.txt");
std::string line;
while (std::getline(file, line)) {
std::stringstream ss(line);
std::string name; int score;
ss >> name >> score;
std::cout << name << ": " << score << "\n";
}
// 파일 쓰기
std::ofstream out("result.txt");
out << "Alice: 95\n";포인터 선언과 역참조, nullptr, 포인터 산술, 포인터와 참조의 차이, const 포인터 네 가지 조합을 정리합니다.
int value = 42;
int* ptr = &value; // &: 주소 연산자 — ptr에 value의 주소 저장
std::cout << ptr; // 주소 출력 (예: 0x7ffee4a1c)
std::cout << *ptr; // 역참조 — 42 출력
*ptr = 100; // 역참조로 원본 수정 → value == 1004 cards
`if`·`else if`·`else`와 C++17 `if` 초기화 문을 어디서 쓰는지, 단락 평가와 `=` vs `==` 같은 대표 실수를 함께 정리합니다.
// 기본 분기
if (score >= 90) {
grade = 'A';
} else if (score >= 80) {
grade = 'B';
} else {
grade = 'C';
}
// C++17: 초기화 + 조건을 한 줄에
if (auto result = find(key); result != end()) {
process(*result);
}인덱스 기반 `for`, range-based `for`, `while`, `do-while`을 어디서 나누는지, 값 복사와 참조 순회 차이, 역방향 순회 함정을 정리합니다.
// 인덱스 기반 — 위치가 필요할 때
for (int i = 0; i < n; ++i) { ... }
// range-based for — 컨테이너 순회
for (const auto& item : collection) { ... }
// 조건 기반 — 종료 시점이 조건에 의존
while (!queue.empty()) { process(queue.front()); queue.pop(); }
// 최소 한 번 실행 보장
do { line = read(); } while (!line.empty());switch가 점프 테이블로 최적화되는 원리, fallthrough를 의도적으로 쓸 때의 패턴, case 안에서 지역 변수를 선언할 때 `{}`가 필요한 이유, `enum class`와 함께 쓰는 방법을 정리합니다.
switch (mode) {
case 0:
std::cout << "off\n";
break;
case 1: { // 지역 변수 있으면 {} 필수
int level = compute();
std::cout << level << "\n";
break;
}
[[fallthrough]]; // C++17: 의도적 fallthrough 표시
default:
std::cout << "unknown\n";
break;
}range-based for가 내부적으로 `begin()`/`end()` 반복자 쌍으로 전개되는 원리, `auto` vs `auto&` vs `const auto&` 선택 기준, 순회 중 컨테이너 수정이 위험한 이유를 정리합니다.
std::vector<std::string> names{"Mina", "Jin", "Soo"};
for (const auto& name : names) { // 읽기 전용 (권장)
std::cout << name << "\n";
}
for (auto& name : names) { // 원소 수정
name += "!";
}
for (auto [key, val] : map) { // 구조적 바인딩 (C++17)
std::cout << key << "=" << val;
}7 cards
C++ 함수 오버로딩이 함수 시그니처로 해결되는 원리, 인자 타입에 따른 오버로드 선택 우선순위, 반환 타입만으로는 오버로딩이 안 되는 이유와 모호성 패턴을 정리합니다.
void print(int n) { std::cout << "int: " << n << "\n"; }
void print(double d) { std::cout << "double: " << d << "\n"; }
void print(const std::string& s){ std::cout << "str: " << s << "\n"; }
print(42); // int 버전 호출
print(3.14); // double 버전 호출
print("hello"); // string 버전 호출struct와 class의 차이, 멤버 변수·멤버 함수·접근 제어의 의미, 불변식을 지키기 위해 왜 class를 쓰는지, 기본 생성자 자동 생성 규칙을 정리합니다.
class Counter {
public:
Counter() : count_{0} { } // 기본 생성자
void increment() { ++count_; }
void reset() { count_ = 0; }
int value() const { return count_; } // const 멤버 함수
private:
int count_; // 외부에서 직접 접근 불가
};
Counter c;
c.increment();
std::cout << c.value(); // 1멤버 초기화 리스트가 생성자 본문 대입보다 효율적인 이유, `const`·참조 멤버가 초기화 리스트를 반드시 써야 하는 이유, 위임 생성자와 `= default`/`= delete` 패턴을 정리합니다.
class Player {
public:
// 멤버 초기화 리스트 — 본문 대입보다 효율적
Player(std::string name, int hp)
: name_{std::move(name)}, hp_{hp}, alive_{true} { }
// 위임 생성자
Player() : Player{"Unknown", 100} { }
private:
std::string name_;
int hp_;
bool alive_;
};기본 인자가 선언 위치(헤더)에서만 지정되어야 하는 이유, 오른쪽부터 기본값을 제공해야 하는 규칙, 오버로딩과 기본 인자의 관계를 정리합니다.
// 선언에서만 기본값 지정 (헤더)
void log(const std::string& msg,
int level = 0,
bool flush = false);
// 정의에서는 기본값 없음 (.cpp)
void log(const std::string& msg, int level, bool flush) { ... }
log("error", 2, true); // 모든 인자 전달
log("warning", 1); // flush = false (기본값)
log("info"); // level = 0, flush = false`this` 포인터가 암묵적으로 전달되는 원리, `const` 멤버 함수에서 `this`가 `const T*`가 되는 이유, 메서드 체이닝을 위한 `*this` 반환 패턴을 정리합니다.
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() { return Server{name_, port_}; }
private:
std::string name_;
int port_ = 8080;
};
auto server = Builder{}.set_name("localhost").set_port(9090).build();선언을 헤더에, 구현을 소스 파일에 두는 이유(재컴파일 범위 최소화), `#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에 접근하는 방법, 비교 연산자와 `<<` 오버로딩 패턴을 정리합니다.
class Vec2 {
public:
double x, y;
Vec2 operator+(const Vec2& o) const { return {x+o.x, y+o.y}; }
Vec2& operator+=(const Vec2& o) { x+=o.x; y+=o.y; return *this; }
bool operator==(const Vec2& o) const { return x==o.x && y==o.y; }
// << 는 비멤버 friend
friend std::ostream& operator<<(std::ostream& os, const Vec2& v);
};
std::ostream& operator<<(std::ostream& os, const Vec2& v) {
return os << "(" << v.x << ", " << v.y << ")";
}4 cards
상속이 코드 재사용과 다형성을 위해 vtable로 동작하는 원리, `virtual` 없이 오버라이드하면 정적 바인딩이 되는 이유, `override`·`final` 키워드의 역할을 정리합니다.
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 r) : r_{r} { }
double area() const override { return 3.14159 * r_ * r_; }
std::string name() const override { return "Circle"; }
private:
double r_;
};
std::unique_ptr<Shape> s = std::make_unique<Circle>(5.0);
std::cout << s->area(); // Circle::area() 호출 — 다형성`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_;
static int total_; // 모든 인스턴스가 공유
static int next_id_;
};
int Counter::total_ = 0; // .cpp에서 정의 필수
int Counter::next_id_ = 0;순수 가상 함수로 인터페이스를 정의하는 추상 클래스의 역할, `override`·`final`로 오버라이드를 컴파일 타임에 검증하는 방법, 인터페이스 분리 원칙을 정리합니다.
class Serializable { // 순수 인터페이스
public:
virtual std::string serialize() const = 0;
virtual void deserialize(const std::string&) = 0;
virtual ~Serializable() = default;
};
class User : public Serializable {
public:
std::string serialize() const override;
void deserialize(const std::string&) override;
private:
std::string name_;
int id_;
};다형성을 쓰는 기반 클래스에서 `virtual ~Base()` 없이 `delete`하면 파생 소멸자가 호출되지 않는 이유, 파생 객체를 기반 클래스 값으로 복사할 때 발생하는 object slicing UB를 정리합니다.
class Animal {
public:
virtual ~Animal() = default; // ✅ virtual 소멸자
virtual void speak() const = 0;
};
class Dog : public Animal {
std::string name_;
public:
explicit Dog(std::string name) : name_(std::move(name)) {}
void speak() const override { std::cout << "Woof: " << name_ << "\n"; }
~Dog() { std::cout << "Dog " << name_ << " destroyed\n"; }
};
Animal* a = new Dog("Rex");
delete a; // ✅ Dog 소멸자 → Animal 소멸자 순으로 호출6 cards
`std::vector`와 `std::string`을 기본 컨테이너처럼 읽는 법, `reserve`와 재할당, `push_back`과 `emplace_back`, 인덱스 접근과 경계 차이를 정리합니다.
#include <vector>
#include <string>
std::vector<int> v{1, 2, 3};
v.push_back(4);
v.reserve(100); // 재할당 방지
std::string s = "Hello";
s += ", World";
std::cout << s.size() << " " << s.substr(0, 5); // 12 Hello레드-블랙 트리 기반 `map`과 해시 테이블 기반 `unordered_map`의 성능 차이, `[]`와 `find`의 차이, `insert_or_assign`·`try_emplace`의 효율적인 삽입 패턴을 정리합니다.
#include <map>
#include <unordered_map>
std::map<std::string, int> scores; // 정렬 순서 유지 (O(log n))
scores["Alice"] = 95;
scores["Bob"] = 88;
std::unordered_map<std::string, int> freq; // 해시, 빠름 (O(1) 평균)
for (const char c : text) ++freq[c];
// 안전한 조회 — find
auto it = scores.find("Charlie");
if (it != scores.end()) use(it->second);`<algorithm>`의 핵심 함수들 — 정렬, 탐색, 변환, 집계, 조건 검사 — 을 반복자 범위와 람다 조합으로 활용하는 방법을 정리합니다.
#include <algorithm>
#include <vector>
std::vector<int> v{7, 2, 9, 4, 1};
std::sort(v.begin(), v.end()); // 오름차순 정렬
std::sort(v.begin(), v.end(), std::greater<int>{}); // 내림차순 정렬
auto it = std::find(v.begin(), v.end(), 4); // 값 탐색
auto it2 = std::find_if(v.begin(), v.end(),
[](int x){ return x > 5; }); // 조건 탐색반복자가 포인터를 추상화하여 알고리즘과 컨테이너를 분리하는 원리, 5가지 반복자 카테고리와 선택 기준, 무효화로 인한 정의되지 않은 동작 패턴을 정리합니다.
std::vector<int> v{1, 2, 3, 4, 5};
// 반복자로 순회
for (auto it = v.begin(); it != v.end(); ++it) {
std::cout << *it << " ";
}
// 알고리즘에 반복자 범위 전달
auto pos = std::find(v.begin(), v.end(), 3);
if (pos != v.end()) std::cout << *pos;
// 역방향 반복자
for (auto it = v.rbegin(); it != v.rend(); ++it) { ... }중복 없는 원소 집합인 `set`(정렬, O(log n))과 `unordered_set`(해시, O(1) 평균)의 차이, 존재 확인·삽입·삭제 패턴, 사용자 정의 타입에 해시 함수를 제공하는 방법을 정리합니다.
#include <set>
#include <unordered_set>
std::set<int> s{3, 1, 4, 1, 5}; // 중복 자동 제거, 정렬
// s = {1, 3, 4, 5}
s.insert(2);
s.erase(3);
bool found = s.count(4) > 0; // 또는 s.contains(4) (C++20)
std::unordered_set<std::string> words;
words.insert("hello");
bool exists = words.count("hello") > 0;컨테이너 어댑터 `stack`(LIFO), `queue`(FIFO), `priority_queue`(최댓값 우선)의 내부 컨테이너 구조, 핵심 API 차이, 최솟값 우선 큐 패턴을 정리합니다.
#include <stack>
#include <queue>
std::stack<int> st;
st.push(10); st.push(20);
st.pop(); // 20 제거
int top = st.top(); // 10
std::queue<int> q;
q.push(1); q.push(2);
q.pop(); // 1 제거
int front = q.front(); // 2
std::priority_queue<int> pq;
pq.push(5); pq.push(1); pq.push(9);
int max = pq.top(); // 9 (최댓값 우선)5 cards
자원 수명을 객체 수명에 연결하는 RAII 원칙, `unique_ptr`(단독 소유)와 `shared_ptr`(공유 소유)의 차이, `make_unique`/`make_shared` 사용 이유, 순환 참조 해결을 위한 `weak_ptr`을 정리합니다.
#include <memory>
// unique_ptr — 단독 소유, 스코프 종료 시 자동 삭제
auto user = std::make_unique<User>("Mina");
user->print();
// shared_ptr — 참조 카운트 기반 공유 소유
auto a = std::make_shared<Node>(42);
auto b = a; // 참조 카운트 2
// a, b 모두 스코프 종료 시 카운트 0 → 자동 삭제lvalue/rvalue 구분, `std::move`가 실제로 하는 일(캐스팅), 이동 생성자·이동 대입 연산자 구현 패턴, 이동 후 원본 객체 상태를 정리합니다.
std::string a = "hello";
std::string b = std::move(a); // a의 자원을 b가 넘겨받을 수 있음
// a는 유효하지만 내용은 보장하지 않음, b는 "hello"
std::vector<std::string> v;
v.push_back(std::move(b)); // b의 소유권을 벡터로 이전컴파일러가 자동 생성하는 6개 특수 멤버 함수, 3의 규칙(Rule of Three)이 필요한 이유, 얕은 복사가 이중 해제를 일으키는 원리, `= default`/`= delete`로 의도를 명확히 하는 방법을 정리합니다.
class Buffer {
public:
explicit Buffer(int size)
: data_{new int[size]}, size_{size} { }
// 복사 생성자 — 깊은 복사
Buffer(const Buffer& other)
: data_{new int[other.size_]}, size_{other.size_} {
std::copy(other.data_, other.data_ + size_, data_);
}
// 복사 대입 연산자
Buffer& operator=(const Buffer& other) {
if (this == &other) return *this; // 자기 대입 방어
delete[] data_;
data_ = new int[other.size_];
size_ = other.size_;
std::copy(other.data_, other.data_ + size_, data_);
return *this;
}
~Buffer() { delete[] data_; }
private:
int* data_;
int size_;
};예외가 발생해도 객체 상태와 자원이 보존되는 basic/strong/nothrow 보장 수준, `noexcept`가 이동 연산 성능에 미치는 영향, `noexcept` 잘못 사용 시 `std::terminate`로 이어지는 이유를 정리합니다.
class Buffer {
std::unique_ptr<int[]> data_;
size_t size_;
public:
// noexcept — 이동 연산은 실패하지 않음을 보장
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_ = other.size_;
other.size_ = 0;
return *this;
}
};`new`와 `delete`로 힙 메모리를 수동 관리하는 방법과 그 위험성, 그리고 스마트 포인터로 전환해야 하는 이유를 정리합니다.
// 힙에 할당
int* p = new int{42};
std::cout << *p; // 42
// 반드시 해제
delete p;
p = nullptr; // 댕글링 포인터 방지
// 배열
int* arr = new int[5]{1, 2, 3, 4, 5};
delete[] arr; // 배열은 delete[] 사용9 cards
lambda 문법 전체 — 캡처 모드 5가지, mutable, 반환 타입 지정, 제네릭 lambda, STL 알고리즘과의 조합까지 정리합니다.
// [캡처](매개변수) -> 반환타입 { 본문 }
auto square = [](int x) { return x * x; };
std::cout << square(5); // 25
// 반환 타입은 대부분 생략 가능 (컴파일러가 추론)
auto greet = [](const std::string& name) {
return "Hello, " + name;
};함수 템플릿과 클래스 템플릿으로 타입에 독립적인 코드를 작성하는 방법, 명시적 특수화, typename과 class 키워드 차이를 정리합니다.
// 함수 템플릿
template <typename T>
T maxOf(T a, T b) {
return a > b ? a : b;
}
// 클래스 템플릿
template <typename T>
class Box {
public:
explicit Box(T value) : value_{value} {}
T get() const { return value_; }
private:
T value_;
};C++17 structured bindings로 pair·tuple·배열·구조체를 분해하는 문법, `auto` vs `auto&` vs `const auto&` 선택 기준, map 순회 패턴을 정리합니다.
#include <map>
#include <tuple>
std::pair<std::string, int> entry{"apple", 3};
auto [name, count] = entry; // .first/.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 <stdexcept>
int divide(int a, int b) {
if (b == 0) throw std::invalid_argument("division by zero");
return a / b;
}
try {
int result = divide(10, 0);
} catch (const std::invalid_argument& e) {
std::cerr << e.what() << "\n"; // "division by zero"
} catch (const std::exception& e) {
std::cerr << "오류: " << e.what() << "\n";
}값이 있을 수도 없을 수도 있는 상태를 타입 수준에서 표현하는 `std::optional`의 생성·확인·접근 패턴, `value_or`·`and_then` 체이닝, sentinel 값 방식과의 비교를 정리합니다.
#include <optional>
std::optional<int> findScore(bool found) {
if (found) return 100;
return std::nullopt;
}
auto score = findScore(true);
if (score) { // bool 변환으로 존재 확인
std::cout << *score << "\n"; // 역참조로 값 접근
}
int val = score.value_or(0); // 없으면 기본값 0소유권 없이 문자열과 연속 메모리를 바라보는 `std::string_view`와 `std::span`의 복사 비용 제거 원리, `const std::string&`과의 차이, dangling view 방지 패턴을 정리합니다.
#include <string_view>
#include <span>
void printName(std::string_view name) { // 복사 없이 모든 문자열 타입 수용
std::cout << name << "\n";
}
void sumScores(std::span<const int> scores) { // vector, array, 배열 모두 수용
int sum = 0;
for (int s : scores) sum += s;
std::cout << sum << "\n";
}
printName("Alice"); // 문자열 리터럴
printName(std::string("Bob")); // std::string
std::vector<int> v{1, 2, 3};
sumScores(v); // vector`union`보다 타입 안전한 `std::variant`, 현재 타입에 따라 분기하는 `std::visit`, `get`/`get_if` 접근 패턴, 상속 계층과 비교 선택 기준을 정리합니다.
#include <variant>
#include <string>
std::variant<int, double, std::string> val = 42;
val = std::string("hello"); // 다른 타입으로 교체
std::visit([](const auto& v) {
std::cout << v << "\n";
}, val); // 현재 담긴 타입에 맞는 분기 자동 선택`std::thread`로 스레드를 생성하고, `mutex`와 `lock_guard`로 공유 데이터를 보호하는 C++ 동시성의 핵심 패턴을 정리합니다.
#include <thread>
#include <mutex>
std::mutex mtx;
int counter = 0;
void increment() {
std::lock_guard<std::mutex> lock{mtx}; // 잠금 (범위 종료 시 자동 해제)
++counter;
}
int main() {
std::thread t1{increment};
std::thread t2{increment};
t1.join(); // t1 완료 대기
t2.join(); // t2 완료 대기
}C++17 `std::filesystem`으로 경로 다루기, 파일/디렉토리 조작, 존재 여부 확인, 디렉토리 순회까지 정리합니다.
#include <filesystem>
namespace fs = std::filesystem;
fs::path p{"data/config.json"};
if (fs::exists(p)) {
std::cout << "크기: " << fs::file_size(p) << " bytes\n";
}