주제별 글 모음

모던 C++ 언어 기능

C++11부터 C++23까지의 기능을 문법 소개보다 "왜 이렇게 쓰는지"와 "어디서 틀리는지"에 무게를 두고 정리합니다. 이동 의미론과 값 카테고리, 람다 캡처, 템플릿 인자 추론, SFINAE와 Concepts, ranges·views가 중심입니다.

Rule of Five, RAII, CRTP, 타입 소거, Visitor 같은 설계 패턴과 객체 수명, 링키지, 헤더 가드처럼 코드 구조에 관한 글도 있습니다. 예제는 컴파일해서 확인했고, 환경이 다르면 결과가 달라질 수 있는 부분은 본문에 환경을 적었습니다.

처음 읽기 좋은 글

• C++ 값 카테고리: lvalue, prvalue, xvalue를 구분하는 기준C++ 표현식이 lvalue, prvalue, xvalue 중 무엇인지 구분하는 기준과, 그 결과가 어떤 참조에 바인딩될 수 있는지를 예제로 정리합니다. std::move가 실제로는 xvalue로 캐스팅할 뿐이라는 점, decltype 결과가 달라지는 규칙, 불필요한 move 실수도 다룹니다.
• C++17·20·23 주요 기능 정리: 구조화 바인딩부터 Concepts·Ranges·std::print까지C++17의 구조화 바인딩, if constexpr, optional, variant, filesystem부터 C++20의 Concepts, Ranges, 코루틴, 모듈, <=> 연산자, C++23의 std::print와 다차원 첨자까지 각 기능이 기존 코드의 어떤 불편을 줄이는지 예제로 비교합니다.

전체 글 330편

각 글에 표시된 난이도를 기준으로 초급, 중급, 고급 순으로 나눴습니다. 처음이라면 위쪽부터 읽고, 이미 아는 단계는 건너뛰어도 됩니다.

초급 (58편)

• #ifndef vs #pragma once: C++ 헤더 가드의 동작 원리와 선택 기준#ifndef 가드와 #pragma once가 전처리기에서 각각 어떻게 중복 포함을 막는지 비교하고, 가드 매크로 이름 충돌, 같은 파일을 가리키는 여러 경로에서 pragma once가 헷갈리는 경우, 순환 포함 문제와 C++20 모듈과의 관계를 설명합니다.
• 주니어에서 시니어까지: C++ 개발자가 단계별로 갖춰야 할 역량승진이 막히거나 다른 언어로 옮길지 고민될 때 참고하도록 주니어에서 시니어로 가는 변화를 코드 작성자에서 시스템 설계자로의 전환으로 설명합니다. 연차별 학습 우선순위와 체크리스트, 도메인별 생태계 차이, 깊이와 너비의 균형, 이직 고민도 다룹니다.
• C++ 값 초기화: int x{}와 int()가 0이 되는 이유와 {}·()의 차이int x;는 쓰레기 값이지만 int x{};와 int()는 0이 되는 이유를 값 초기화 규칙으로 설명합니다. 기본 타입과 클래스에서 결과가 어떻게 다른지, new 연산자와 배열·멤버 초기화에서의 동작, {}와 ()의 문법적 차이를 예제로 다룹니다.
• C++ 개발 환경 구축 | Windows·macOS·Linux 컴파일러 설치와 첫 빌드Windows에서는 Visual Studio, MinGW, WSL 중 무엇을 고를지, macOS에서는 Command Line Tools와 Homebrew GCC를, Linux에서는 배포판별 패키지를 설치해 첫 프로그램을 빌드합니다. g++을 찾을 수 없음, cl 인식 실패, IntelliSense 오류 해결법도 담았습니다.
• C++ 기본 인자 규칙: 헤더에만 두는 이유와 가상 함수에서 생기는 함정C++ 기본 인자를 오른쪽부터 채워야 하는 규칙, 헤더 선언에만 기본값을 두고 재선언에서 반복하면 안 되는 이유, 가상 함수에서 기본값이 정적 타입 기준으로 결정되는 함정, 오버로딩과 충돌하는 경우를 예제로 설명합니다.
• C++ 기본 초기화: 지역 변수가 쓰레기 값을 갖는 이유와 전역·정적 변수와의 차이초기화자 없이 선언한 지역 int나 포인터가 쓰레기 값을 갖는 기본 초기화 규칙을 설명하고, 전역·정적 변수가 0으로 초기화되는 차이, 클래스 멤버와 배열에서 초기화가 빠지는 경우, 값 초기화와의 비교를 다룹니다.
• C++ 문자열 파싱이 병목일 때: stringstream·getline 대신 string_view 제로카피, 벤치마크입력은 빨리 받았는데 split 이후 시간 초과가 나는 상황을 두고 stringstream·getline·find+substr·strtok·regex 방식의 차이를 비교합니다. string_view 제로카피 파싱, 따옴표 필드를 지원하는 CSV 파서, string_view 댕글링 같은 버그도 다룹니다.
• C++ 반복문: for/while/do-while과 무한 루프·off-by-one 실수 피하기for, while, do-while을 어떤 상황에 고르는지, 범위 기반 for의 동작, off-by-one과 세미콜론으로 생기는 무한 루프, 중첩 루프를 플래그·함수 분리·goto로 빠져나오는 방법을 구구단·소수 판별 예제로 익힐 수 있습니다.
• C++ 반환 방식 고르기: 값·레퍼런스·포인터 반환, RVO를 막는 return std::move함수에서 값, 레퍼런스, 포인터 중 무엇으로 반환할지 정하는 기준과 지역 변수 레퍼런스를 반환해 댕글링이 되는 문제, 일부 경로에서 return이 빠지는 실수, return std::move가 RVO를 막는 이유, pair·tuple·optional로 여러 값을 돌려주는 방법을 설명합니다.
• C++ 스택 vs 힙 | 재귀에서 프로그램이 죽는 이유와 스택 오버플로우 사례깊은 재귀로 프로그램이 갑자기 죽는 사례에서 출발해 스택과 힙이 메모리에서 어떻게 다르게 동작하는지, 힙 할당이 느린 이유, delete와 delete[]를 헷갈리는 실수, 언제 스택을 쓰고 언제 힙에 할당할지 판단하는 기준을 예제로 설명합니다.
• C++ 스톱워치와 벤치마크 | chrono로 실행 시간 측정하기외부 라이브러리 없이 <chrono>만으로 재사용 가능한 스톱워치 클래스와 스코프가 끝날 때 시간을 찍는 RAII 타이머를 만듭니다. 여러 번 측정해 평균·중앙값 등으로 해석하는 법, 컴파일러가 측정 대상 코드를 지워 버리는 문제를 막는 법도 다룹니다.
• C++ 연산자 우선순위 함정: flags & MASK == 0 같은 비트·비교·논리 연산자 버그flags & MASK == 0이 의도와 달리 비교부터 계산되는 것처럼 비트, 비교, 논리 연산자가 섞일 때 생기는 버그를 우선순위와 결합 방향 표로 풀어 봅니다. 증감 연산자, 대입과 비교 혼동, && 단축 평가를 예제로 보고 괄호를 어디에 치면 좋은지 정리합니다.
• C++ 입문 개요 | 역사, 현대 C++의 변화, 실무에서 쓰이는 분야C++의 역사(C with Classes부터 C++26까지)와 표준화 흐름, 게임·금융·임베디드·시스템 소프트웨어에서 왜 여전히 C++가 선택되는지, 그리고 학습 로드맵과 커리어 경로까지 다룹니다.
• C++ 전처리기 제대로 쓰기: #define과 #ifdef 실전 패턴redefinition 에러, Windows와 Linux API 분기, 디버그 빌드 전용 로그, __FILE__과 __LINE__을 넣은 assert처럼 전처리기가 필요한 상황을 예제로 풀고, 가변 인자 매크로와 확장 순서, 인자에 쉼표가 든 매크로의 함정을 설명합니다.
• C++ 조건문: if/else/switch 사용법과 흔한 실수조건문을 처음 쓸 때 if-else if 사슬과 switch 중 무엇을 고를지, break를 빼먹어 다음 case로 흘러가는 fall-through, if (x = 5) 같은 대입 실수를 성적 계산기, ATM 메뉴, 윤년 판별 예제로 익히고 바로 고칠 수 있게 합니다.
• C++ 집합체 초기화: 집합체 조건, 중괄호 초기화, C++20 지정 초기화 순서 규칙C++ 집합체가 되기 위한 조건과 중괄호로 구조체·배열·중첩 구조체를 초기화하는 방법, C++20 지정 초기화의 순서 규칙과 기본값 처리, 설정 구조체와 테스트 데이터에 집합체를 활용하는 패턴을 예제로 설명합니다.
• C++ 컴파일 과정 4단계: 전처리·컴파일·어셈블·링킹과 undefined reference가 나는 이유소스 파일이 전처리, 컴파일, 어셈블, 링킹을 거쳐 실행 파일이 되는 과정을 단계별 명령으로 확인하고, undefined reference가 링크 순서나 이름 맹글링 때문에 생기는 이유, 정적 라이브러리와 동적 라이브러리의 차이, 수정이 빌드에 반영되지 않는 문제를 다룹니다.
• C++ 컴파일러 비교 | GCC vs Clang vs MSVC, 어떤 걸 써야 할까?전처리, 구문 분석, 최적화, 코드 생성 단계를 직접 실습하며 같은 코드가 컴파일러마다 다르게 빌드되는 이유를 살펴보고, GCC의 -O2와 -O3 선택, Clang의 친절한 에러 메시지와 정적 분석, MSVC의 특징을 비교해 프로젝트에 맞는 컴파일러를 고릅니다.
• C++ 클래스와 객체 입문: 설계도 비유로 이해하는 생성자·접근 제어·소멸자클래스는 설계도, 객체는 그 설계도로 만든 실체라는 비유로 첫 C++ 클래스를 작성해 봅니다. 생성자와 소멸자가 언제 호출되는지, public·private 접근 제어가 왜 필요한지, 세미콜론 누락 같은 초보자 실수를 예제로 짚습니다.
• C++ 포인터 처음 배우기: &와 * 연산자, swap·배열 순회, 초보자가 하는 첫 실수변수는 집, 주소는 집 주소라는 비유로 &와 * 연산자가 하는 일을 그림과 함께 설명하고, swap 함수와 배열 순회로 포인터를 직접 써 봅니다. 초기화하지 않은 포인터, 댕글링 포인터, new 후 delete 누락 같은 첫 실수도 짚습니다.
• C++ 프로젝트용 Makefile 작성: 변수, 패턴 규칙, 의존성 자동 생성, 병렬 빌드Makefile은 Make가 사용하는 빌드 자동화 스크립트입니다. 컴파일과 링킹을 자동화하여 개발 생산성을 높입니다. 증분 빌드·병렬(make -j)은 CMake가 생성하는 Makefile/Ninja와도 같은 맥락입니다.
• C++ 함수 오버로딩: 오버로드 해석 순서와 모호한 호출이 생기는 경우같은 이름의 함수 중 어떤 것이 호출될지 컴파일러가 정하는 오버로드 해석 순서를 설명하고, 반환 타입만 다른 오버로딩이 불가능한 이유, const 오버로딩, 기본 인자 때문에 생기는 모호한 호출, 배열이 포인터로 바뀌는 함정을 예제로 풀어 봅니다.
• C++ 함수 처음 만들기: 선언과 정의, 값·참조 전달, 오버로딩, 기본 인자 (예제 10개)함수를 처음 만들 때 필요한 선언과 정의의 분리, 값·참조·포인터 전달의 차이, return 규칙, 기본 매개변수, 오버로딩을 예제 10개로 익힙니다. 지역 변수 주소 반환, 오버로딩 모호성, 선언 전 호출 같은 초보자 실수도 짚습니다.
• C++ 헤더 파일 작성법: 선언과 정의 분리, 인클루드 가드, ODR 위반과 순환 include무엇을 헤더에 두고 무엇을 .cpp에 둘지 선언과 정의의 차이로 정리하고, 인클루드 가드와 pragma once로 중복 포함을 막는 법, 헤더에 함수를 정의해 생기는 ODR 위반, 순환 인클루드, 불필요한 인클루드를 줄이는 방법을 예제로 설명합니다.
• C++ Adapter 패턴: 객체 어댑터 vs 클래스 어댑터로 레거시·외부 API 감싸기C++에서 호환되지 않는 인터페이스를 연결하는 Adapter 패턴을 조합 방식의 객체 어댑터와 다중 상속 방식의 클래스 어댑터로 구현해 비교하고, 레거시 API 감싸기, 팩토리·템플릿 어댑터, 결제 시스템 예제를 다룹니다.
• C++ C 배열 vs std::array vs vector: 성능과 안전성 비교C 스타일 배열, std::array, std::vector를 크기 고정 여부, 스택·힙 배치, 범위 검사 관점에서 비교하고, 접근·생성·순회 비용이 어디서 갈리는지 설명합니다. operator[]와 at()의 차이, 함수로 넘길 때 크기 정보가 사라지는 문제도 다룹니다.
• C++ count·count_if와 all_of·any_of·none_of로 조건 집계하기std::count로 특정 값의 개수를 세고 count_if에 람다를 넘겨 조건별로 집계하는 방법, 구조체 필드 기준 카운트, all_of·any_of·none_of로 조건을 검사하는 법을 통계 유틸리티 예제와 함께 설명합니다.
• C++ fill·generate·iota로 범위 채우기: 테스트 데이터 생성 예제std::fill과 fill_n으로 범위를 같은 값으로 채우고, generate에 람다나 함수 객체를 넘겨 난수·ID·구조체 데이터를 만들며, iota로 연속 값을 생성하는 방법을 테스트 데이터 생성기 예제와 함께 설명합니다.
• C++ friend: private 접근을 열어 줄 때, operator<<와 대칭 연산자, getter와 비교friend는 특정 함수나 클래스에만 private 멤버 접근을 허용합니다. operator<< 같은 스트림 연산자와 대칭 비교 연산자를 friend로 만드는 이유, friend가 상속되지 않는다는 규칙, getter를 늘리는 것과 비교한 판단 기준을 예제로 설명합니다.
• C++ I/O 병목 줄이기: cin·mmap·io_uring 성능 비교같은 로직인데 C++만 시간 초과가 나는 이유를 sync_with_stdio, cin.tie, endl의 버퍼 플러시로 설명하고 getchar 직접 파싱과 출력 버퍼링까지 단계별로 최적화합니다. 대용량 파일용 mmap과 liburing 기반 io_uring 예제도 다룹니다.
• C++ Include Path | 인클루드 경로 가이드#include "file.h"와 #include <file.h>가 헤더를 찾는 순서의 차이, -I 옵션과 CMake target_include_directories로 경로를 추가하는 법, GCC/Clang에서 시스템 경로를 확인하는 명령, 같은 이름 헤더가 충돌할 때의 해결법을 예제로 설명합니다.
• C++ iostream 다루기: 포매팅 조작자, stringstream 파싱, cin 버퍼와 스트림 실패 상태C++ iostream으로 콘솔·문자열·파일 입출력을 다루는 방법을 정리합니다. 포매팅 조작자, stringstream, CSV·설정 파일 파싱 실전 예제와 cin 버퍼·스트림 실패 상태 함정을 다룹니다.
• C++ Iterator 카테고리 이해하기: begin/end부터 성능 비교까지순회 중 erase 후 크래시가 나는 문제에서 출발해 반복자 카테고리별 지원 연산, 반개구간 [begin, end), reverse_iterator의 base() 변환, back_inserter 같은 어댑터를 예제로 설명합니다. std::advance와 distance 사용법도 다룹니다.
• C++ min·max·minmax_element와 std::clamp: 값 비교와 범위 제한두 값 비교용 std::min·max·minmax와 범위용 min_element·max_element·minmax_element의 차이, 커스텀 비교자, C++17 std::clamp로 마우스 좌표를 화면 안으로 제한하는 예제와 통계·정규화 패턴을 다룹니다.
• C++ nullptr vs NULL: NULL이 정수라서 생기는 오버로드·템플릿 버그NULL이 사실상 정수 0이라서 int를 받는 오버로드와 섞이면 모호한 호출이나 의도와 다른 함수 선택이 생기고, 템플릿과 auto 추론에서는 포인터가 아닌 정수로 잡히는 문제를 보여줍니다. nullptr_t가 이를 막는 원리와 clang-tidy로 기존 코드를 옮기는 방법도 설명합니다.
• C++ numeric_limits: 타입 최댓값·최솟값·NaN 조회와 오버플로우 검사std::numeric_limits로 정수와 실수 타입의 최댓값, 최솟값, 정밀도, infinity와 NaN을 조회해 오버플로우 전에 덧셈을 검사하거나 안전하게 타입을 변환하는 방법을 다룹니다. 실수 타입에서 min()이 가장 작은 음수가 아니라는 함정도 설명합니다.
• C++ queue와 stack: 컨테이너 어댑터 사용법과 BFS·DFS 활용C++ STL의 stack·queue·priority_queue 사용법과 내부 동작 원리를 비교하고, DFS·BFS·작업 스케줄링 실전 예제와 커스텀 비교자 설정 등 흔한 컴파일 에러 해결법을 정리합니다.
• C++ replace·replace_if·replace_copy: 값 치환과 transform 중 무엇을 쓸까std::replace와 replace_if로 원본 범위의 값을 바꾸고, replace_copy·replace_copy_if로 원본을 유지한 채 결과를 새로 만드는 방법, std::string::replace와의 혼동, transform과의 선택 기준을 데이터 정제 예제로 설명합니다.
• C++ reverse·rotate·reverse_copy: 범위 뒤집기와 회전 알고리즘 사용법std::reverse로 범위를 뒤집고 reverse_copy로 원본을 유지한 채 역순 사본을 만들며, rotate로 배열을 회전하는 방법을 팰린드롬 검사, LeetCode 189 배열 회전, 151 단어 순서 뒤집기 예제로 설명합니다.
• C++ size_t와 ptrdiff_t: 부호 없는 인덱스 함정과 std::ssize·cmp_lesssize_t는 크기·인덱스에, ptrdiff_t는 포인터 차이에 쓰는 표준 별칭입니다. 부호 있는/없는 혼합, 루프·역방향 순회, 이식성과 경고를 줄이는 패턴을 정리합니다. C++20 std::ssize·std::cmp_less처럼 혼합 비교를 안전하게 만드는 도구도 다룹니다.
• C++ sleep_for·sleep_until로 주기 작업 만들기: 누적 드리프트와 짧은 sleep의 부정확함sleep_for와 sleep_until, yield로 주기 작업과 타임아웃을 만들 때 생기는 문제를 예제로 다룹니다. sleep_until로 누적 드리프트를 줄이는 법, 짧은 sleep의 부정확함, 바쁜 대기의 비용, steady_clock을 써야 하는 이유, Asio 타이머와의 연계도 설명합니다.
• C++ static 멤버 변수와 함수: 초기화 순서, 스레드 안전성, C++17 inline staticC++ static 멤버 변수·함수의 동작 원리를 싱글톤, 카운터, 설정 관리자, 팩토리 실전 예제로 정리합니다. 초기화 순서 함정, 스레드 안전성, C++17 inline static까지 다룹니다.
• C++ std::copy·copy_if·copy_backward: 목적지 크기, 겹치는 범위, back_inserterstd::copy·copy_if·copy_n·copy_backward·move를 언제 골라 쓰는지 벡터 복제와 필터링 예제로 설명하고, 목적지 크기 부족, 겹치는 범위, move 후 원본 상태, back_inserter 같은 출력 반복자 선택 문제를 다룹니다.
• C++ std::string 자주 쓰는 함수 정리: 검색·치환·분할과 흔한 실수, 성능 팁C++ std::string 사용법 정리. 생성과 연결, find·substr·replace 같은 자주 쓰는 함수, 문자열 분할 같은 실전 예시, 자주 생기는 문제와 성능 최적화 팁을 예제로 다룹니다.
• C++ std::vector 기초: 생성·삽입·삭제와 배열 대신 쓰는 이유크기가 고정되고 범위 검사도 없는 C 배열 대신 std::vector를 쓰는 이유를 선언, 추가·삭제, operator[]와 at() 차이, 2차원 벡터, sort·find 예제로 보여줍니다. size()를 int로 받는 실수, 반복 중 삭제, reserve와 resize 혼동도 다룹니다.
• C++ STL 알고리즘 기초: sort·find·transform·accumulate 실전 활용for문으로 직접 짠 정렬·검색·집계에서 버그가 나는 상황을 std::sort, find_if, count_if, transform, accumulate로 바꾸는 방법을 보여줍니다. remove 후 erase 누락, accumulate 초기값 실수, 비교자 규칙 위반도 짚습니다.
• C++ struct vs class: 기본 접근 제어, POD, C 호환성의 차이C++에서 struct와 class의 문법상 차이는 멤버와 상속의 기본 접근 지정자뿐입니다. 그런데도 데이터 묶음에는 struct, 불변식을 지키는 캡슐화에는 class를 쓰는 관례가 왜 생겼는지, POD 조건과 C 호환, memcpy 가능 여부까지 설명합니다.
• C++ this 포인터: 메서드 체이닝, 자기 대입 검사, 람다 this 캡처 수명멤버 함수 안의 this가 호출한 객체를 가리키는 원리를 메서드 체이닝, 자기 대입 방지, 콜백 등록 예제로 보여줍니다. 매개변수와 멤버 이름 충돌, static 멤버 함수에 this가 없는 이유, 람다에 [this]를 캡처했을 때의 수명 문제도 다룹니다.
• C++ typedef vs using: 템플릿 별칭과 함수 포인터 별칭, 별칭은 새 타입이 아니다중첩된 map<string, vector<pair<...>>> 같은 긴 타입에 이름을 붙일 때 typedef와 C++11 using이 어떻게 다른지 비교합니다. using만 가능한 템플릿 별칭, 읽기 쉬운 함수 포인터 별칭, 별칭이 새 타입을 만들지 않는다는 점에서 생기는 실수를 다룹니다.
• C++ vector reserve vs resize: capacity와 size의 차이와 쓰임vector의 reserve는 capacity만 늘리고 size는 그대로 두지만, resize는 요소를 실제로 만들고 초기화해 size를 바꿉니다. 이 차이 때문에 reserve 뒤 인덱스로 접근하거나 resize 뒤 push_back을 하면 생기는 버그와 재할당 횟수 차이를 예제로 보여 줍니다.
• C++11 random 라이브러리: rand() % n이 편향되는 이유와 mt19937·분포 사용법rand() % n이 편향되는 이유와 mt19937 엔진에 분포를 조합하는 C++11 random 사용법을 주사위, 셔플, 가중치 랜덤 예제로 보여주고, 호출마다 엔진을 새로 만드는 실수, random_device의 함정, 플랫폼별 분포 결과 차이를 설명합니다.
• C++17 구조적 바인딩: map·pair·tuple 분해와 auto&·const auto& 선택auto [key, value] 한 줄로 map 요소, pair, tuple, 구조체를 이름 있는 변수로 푸는 C++17 구조적 바인딩을 다룹니다. auto&·const auto& 선택, insert 결과를 if 초기화문과 함께 받는 패턴, 커스텀 타입에 튜플 프로토콜을 붙이는 방법을 예제로 봅니다.
• C++20 지정 초기화(Designated Initializers): 필드 이름으로 구조체 초기화하기와 순서 규칙C++20 Designated Initializers로 구조체를 명확하게 초기화하는 방법. 기본 문법, C와 다른 순서 규칙, 중첩 구조체, 기본값과 부분 초기화, HTTP 요청 설정 예제를 정리합니다.
• CMake 입문: CMakeLists.txt로 C++ 프로젝트를 크로스플랫폼 빌드하기g++ 명령을 손으로 치던 빌드를 CMakeLists.txt로 옮기는 과정을 Hello World부터 멀티파일 프로젝트까지 따라가며, Make와 Ninja 생성기 차이, Debug와 Release 빌드, find_package로 외부 라이브러리를 연결하는 방법을 복사해 쓸 수 있는 예제로 설명합니다.
• GCC vs Clang vs MSVC: 같은 코드로 비교한 최적화 플래그, C++23/26 지원, 플랫폼 차이같은 example.cpp를 GCC, Clang, MSVC로 빌드해 최적화 플래그별 결과와 에러 메시지가 어떻게 다른지 비교하고, C++23·C++26 표준 지원 현황, 표준 라이브러리 구현 차이, 운영체제별로 어떤 컴파일러를 권장하는지 정리합니다.
• GDB로 C++ 디버깅하기: 브레이크포인트, 워치포인트, backtrace, Core Dump 분석GDB로 C++ 프로그램을 디버깅하는 방법. 디버그 빌드, 조건부 브레이크포인트, 워치포인트, backtrace와 변수 검사, step/next/continue, Core Dump 분석과 역방향 디버깅을 예제로 다룹니다.
• macOS에서 LLDB로 C++ 디버깅하기: 브레이크포인트, 워치포인트, frame variable, GDB 명령 대응표macOS에서 LLDB로 C++를 디버깅하는 방법. 디버거 권한과 코드 서명(Developer Mode, get-task-allow, SIP), frame variable과 expression의 차이, 조건부 브레이크포인트·워치포인트·backtrace, dSYM, GDB 명령어 대응표를 정리합니다.
• VS Code C++ 설정 방법: IntelliSense 빨간 밑줄, tasks.json 빌드, launch.json 디버깅, clangdVS Code에서 C++ IntelliSense·빌드·디버깅을 설정하는 방법. compilerPath와 compile_commands.json, MSVC의 개발자 명령 프롬프트, Apple Silicon의 macos-clang-arm64와 LLDB 디버거 선택, clangd로 바꿀 때 충돌 막기, Cursor·VSCodium에서 C/C++ 확장이 동작하지 않는 이유까지 정리합니다.

중급 (165편)

• [[nodiscard]]로 반환값 무시 막기: 에러 코드, RAII 타입, 사유 메시지, Clang-Tidy 검증C++ [[nodiscard]] 정리. 반환값을 무시해서 생기는 버그, 에러 코드와 RAII 타입에 붙이는 법, C++20 사유 메시지와 생성자 적용, Clang-Tidy 검증, C++26 std::ignore 논의를 다룹니다.
• 2026년 Boost 라이브러리 훑어보기: Asio·Beast·Filesystem 설치와 활용Boost를 apt·vcpkg·소스로 설치해 CMake find_package로 연결하는 과정, Asio·Filesystem·Regex·Program_options 예제, undefined reference·ABI 불일치 같은 링크 에러 해결, 표준 라이브러리로 옮길 시점까지 다룹니다.
• C++ <numeric> 알고리즘: accumulate·reduce·scan의 차이와 함정<numeric>의 accumulate와 C++17 reduce·transform_reduce의 차이, inner_product, partial_sum과 inclusive·exclusive_scan, adjacent_difference, iota를 통계·복리 이자·이동 평균 계산 예제로 설명합니다.
• C++ = default와 = delete: 특수 멤버 함수 제어와 복사 금지·이동 전용 타입C++11 = default와 = delete로 특수 멤버 함수를 명시적으로 제어하는 방법을 설명합니다. 복사는 막고 이동만 허용하는 리소스 래퍼, 힙 할당 금지, 특정 타입 변환 차단, 싱글톤 예제와 Rule of Zero를 다룹니다.
• C++ 가변 인자 템플릿: 파라미터 팩 재귀 전개, Fold Expression, 완벽한 전달C++ 가변 인자 템플릿 정리. template<typename... Args>와 파라미터 팩, 재귀 전개 패턴, C++17 Fold Expression, std::tuple 이해, 완벽한 전달과 자주 나는 에러를 예제로 다룹니다.
• C++ 가상 함수 현장 매뉴얼 | 설계·비용·override·실무 패턴 한글 정리가상 함수를 언제 쓰고 언제 템플릿이나 variant로 대체할지, override/final로 시그니처 실수를 막는 법, NVI 관용구, 다형 호출 비용과 캐시 친화 설계, 자주 보이는 안티패턴을 정리합니다.
• C++ 가상 함수와 vtable: 호출 비용, Devirtualization, CRTP 대안가상 함수 호출이 vtable과 vptr을 거쳐 결정되는 과정을 메모리 레이아웃과 다이어그램으로 설명하고, 가상 소멸자가 없을 때 생기는 문제를 코드로 보여줍니다. 기본 인자, 생성자 안 가상 호출, 객체 슬라이싱 같은 실수와 devirtualization·CRTP 대안도 다룹니다.
• C++ 객체 수명과 저장 기간: 생성·소멸 순서, 임시 객체 수명, 댕글링 참조C++ 객체 수명(lifetime)과 저장 기간(자동/정적/동적/스레드)의 차이, 생성·소멸 순서 규칙을 실전 예제로 정리합니다. 댕글링 참조·정적 초기화 순서 대란·임시 객체 수명 함정과 RAII·스마트 포인터 해법까지 다룹니다.
• C++ 객체 슬라이싱: 파생 부분이 잘려 나가는 네 가지 경우와 다형성 지키는 법파생 객체를 기반 클래스 값으로 넘기거나 반환하고, 대입하거나 vector에 담는 네 가지 경우에 파생 부분이 잘려 나가는 이유를 메모리 레이아웃으로 보여주고, 참조·포인터·스마트 포인터와 복사 방지로 다형성을 지키는 법을 설명합니다.
• C++ 고성능 RPC 시스템: gRPC와 Protocol Buffers를 이용한 마이크로서비스 구축HTTP/JSON만으로 부족해진 서비스 간 통신을 gRPC와 Protocol Buffers로 옮기는 과정을 .proto 작성과 CMake 코드 생성부터 보여줍니다. 동기 서버와 CompletionQueue 비동기 서버, 스트리밍, DEADLINE_EXCEEDED 같은 상태 코드 대처를 다룹니다.
• C++ 관찰 포인터: 소유하지 않는 참조를 원시 포인터·weak_ptr로 표현하는 기준소유하지 않고 가리키기만 하는 관찰 포인터를 부모-자식 관계, 콜백, 컨테이너 요소 접근, 이벤트 시스템에서 쓰는 방법과 원시 포인터, unique_ptr, weak_ptr 중 무엇으로 표현할지, 대상이 먼저 소멸해 생기는 댕글링을 막는 법을 다룹니다.
• C++ 댕글링 레퍼런스: 지역 변수 반환·임시 객체·컨테이너 요소에서 생기는 원인과 탐지C++ 댕글링 레퍼런스가 발생하는 네 가지 근본 원인(지역 변수 반환, 임시 객체, 컨테이너 요소, 해제된 메모리)을 실전 예제로 정리합니다. 반복자 무효화, 스마트 포인터, 람다 캡처, 메서드 체이닝 함정과 탐지·해결 방법까지 다룹니다.
• C++ 도메인별 요구 역량: 네카라쿠배·금융(HFT)·게임 서버·임베디드 비교게임 서버 경험으로 금융에 지원했다가 맞지 않는 식의 도메인 불일치 사례에서 출발해, 대형 IT 백엔드와 금융·HFT, 게임 서버, 임베디드·시스템 소프트웨어가 강조하는 면접 포인트와 최적화 방향을 비교합니다. 같은 이벤트 처리 요구를 세 스타일로 구현한 코드와 도메인 간 전환 전략도 다룹니다.
• C++ 디자인 패턴 | Adapter·Decorator외부 라이브러리 인터페이스가 맞지 않거나 기존 코드를 고칠 수 없을 때 Adapter와 Decorator로 감싸는 방법을 먼저 보여주고, Proxy·Bridge·Composite까지 구조 패턴을 예제로 비교합니다. 세 래퍼 패턴이 헷갈리는 지점과 Decorator 체인의 메모리 관리도 다룹니다.
• C++ 디자인 패턴 | Observer·Strategy데이터 변경을 여러 UI에 알리다 강한 결합이 생기는 문제에서 출발해, C++로 Observer·Strategy·Command·State·Template Method 패턴을 구현하고 notify 중 detach, 상태 전이 시 수명 문제 같은 함정을 다룹니다.
• C++ 디자인 패턴 실전 | Singleton·Factory·Observer·Strategy·PIMPL 예제와 자주 하는 실수전역 설정 접근, if-else로 늘어나는 객체 생성, 여러 UI에 변경 알리기, 알고리즘 교체, 헤더 하나 고쳤는데 오래 걸리는 재빌드를 Singleton, Factory, Observer, Strategy, PIMPL로 푸는 예제를 모았습니다. 패턴별로 자주 하는 실수도 짚습니다.
• C++ 람다 심화 | 초기화 캡처·완벽 전달·IIFE·재귀 람다와 실전 패턴unique_ptr을 스레드로 넘기는 문제에서 출발해 초기화 캡처로 소유권을 옮기는 법, 제네릭 람다의 완벽 전달, IIFE로 const 변수를 초기화하는 패턴을 다룹니다. 재귀 람다는 std::function, Y combinator, C++23 deducing this를 비교합니다.
• C++ 람다 표현식: 캡처·mutable·제네릭 람다부터 deducing this 재귀까지[=]·[&]·초기화 캡처·this 캡처가 각각 무엇을 복사하고 무엇을 참조하는지, mutable과 제네릭·템플릿 람다, IIFE, 재귀 람다(std::function·Y-combinator·C++23 deducing this), constexpr/consteval 람다까지 한 글에서 다룹니다. 댕글링 참조, for 루프 변수 캡처, this 캡처 후 객체 소멸 같은 오류와 std::function에 담을 때의 비용도 설명합니다.
• C++ 로깅·Assertion | 프로덕션 간헐적 크래시, 로그 없이 재현 불가일 때로그가 없어 재현조차 안 되는 프로덕션 크래시를 계기로 로그 레벨 설계, assert와 static_assert의 쓰임 구분, spdlog의 싱크·포맷·로테이션 설정을 다룹니다. assert에 부수 효과를 넣거나 사용자 입력 검증에 assert를 쓰는 실수도 설명합니다.
• C++ 메모리 누수: 흔한 5가지 패턴과 Valgrind·ASan으로 찾는 방법early return으로 delete를 건너뛰는 서버 코드를 출발점으로 이중 삭제, 댕글링 포인터, 누수, delete와 delete[] 혼동, 예외 안전성 무시 5가지 패턴을 재현하고, Valgrind와 AddressSanitizer가 각각 무엇을 어떻게 보고하는지 보여줍니다.
• C++ 메모리 풀 구현 비교: 객체 풀, 슬랩 할당자, 아레나, std::pmr프로파일러에서 malloc이 상위에 뜨거나 힙 단편화·락 경합이 생길 때 쓸 수 있는 객체 풀, 슬랩 할당자, 메모리 아레나, std::pmr을 직접 구현하며 비교합니다. 풀보다 오래 사는 객체, 잘못된 풀 반환, pmr 리소스 수명 같은 실수도 짚습니다.
• C++ 문법 선택 기준표: tuple, 구조적 바인딩, using, <=>, 사용자 정의 리터럴을 직접 실행해 고르기코드 리뷰에서 자주 고민하는 tuple과 struct, auto와 auto&, typedef와 using, 삼원 비교, 초기화 캡처, size_t 같은 선택을 한 프로그램으로 실행해 확인했습니다. 각 선택의 결과와 자세한 글 링크를 표로 정리했습니다.
• C++ 문자열 다루기: std::string 연산, C 문자열 변환, string_view와 SSO 성능C++ 문자열 정리. std::string 주요 연산, C 문자열과의 비교와 변환, std::string_view(C++17)의 사용법과 수명 함정, SSO가 성능에 미치는 영향을 예제로 다룹니다.
• C++ 바이너리 직렬화: 엔디안·구조체 패딩 문제와 버전 관리·체크섬게임 세이브 파일이 다른 PC에서 깨지는 원인을 엔디안과 구조체 패딩으로 추적하고, string·vector 같은 동적 데이터를 길이와 함께 안전하게 저장하는 방법을 보여줍니다. 포맷 버전 관리, 체크섬, 원자적 쓰기와 백업 같은 운영 패턴도 다룹니다.
• C++ 반복자: 종류와 연산, iterator_traits, 범위 기반 for의 디슈가링Input부터 Random Access까지 반복자 카테고리별로 허용되는 연산과 복잡도, iterator_traits와 C++20 iterator_concept, 범위 기반 for가 실제로 어떤 코드로 풀리는지, 그리고 무효화된 반복자와 end() 역참조 같은 버그를 예제로 설명합니다.
• C++ 범위 기반 for문과 구조화된 바인딩 | 모던 C++ 반복문C++11 범위 기반 for와 C++17 구조화된 바인딩 사용법. auto·auto&·const auto&·auto&& 선택, map 순회, 임시 객체 수명(메서드 체인은 C++20까지 위험), vector<bool> 프록시, 커스텀 타입의 begin/end, 순회 중 수정 금지와 실전 패턴을 예제로 정리합니다.
• C++ 복사 생성자와 이동 생성자: 호출 시점, Rule of Five와 Rule of ZeroC++ 복사 생성자와 이동 생성자가 호출되는 시점을 동적 배열, 파일 핸들러, 간단한 스마트 포인터 예제로 보여 주고, Rule of Five와 Rule of Zero, 얕은 복사·자기 대입·noexcept 누락 문제를 설명합니다.
• C++ 사용자 정의 리터럴: 리터럴 연산자 문법, cooked·raw 오버로드, 접미사 규칙C++11 사용자 정의 리터럴(operator"") 문법과 언더스코어 접두사 규칙, cooked·raw 오버로드 선택 기준, chrono 리터럴 합성 원리, 접미사 충돌 함정을 실전 코드로 정리합니다.
• C++ 상속과 다형성: virtual 함수, 추상 클래스, 가상 소멸자 누락과 슬라이싱C++의 상속(Inheritance)과 다형성(Polymorphism)을 게임 캐릭터·결제 시스템 예제로 정리합니다. virtual 함수, 순수 가상 함수, 가상 소멸자 누락과 슬라이싱 같은 실무에서 자주 겪는 함정을 다룹니다.
• C++ 생성 패턴 실무 활용: Singleton·Factory·Builder·Prototype전역 설정 접근, 다형적 객체 생성, 파라미터가 너무 많은 생성자 같은 문제를 Singleton, Factory, Builder, Prototype이 각각 어떻게 푸는지 보여줍니다. 스레드 안전 Singleton, 정적 초기화 순서 문제, 얕은 복사 함정도 다룹니다.
• C++ 성능 측정: chrono와 Google Benchmark로 신뢰할 수 있는 벤치마크 만들기std::chrono 고해상도 시계로 C++ 코드를 측정할 때 워밍업, 반복 실행, 통계 수집을 어떻게 구성하는지 설명하고, Google Benchmark의 DoNotOptimize와 사용자 정의 카운터로 정렬·컨테이너·해시 함수를 비교하는 방법을 다룹니다.
• C++ 소멸자와 RAII: 가상 소멸자, 규칙 0, 소멸자에서의 예외소멸자 호출 순서, 가상 소멸자가 필요한 정확한 조건과 대안(protected 비가상), Rule of 0/3/5, 소멸자에서의 예외·this 사용 함정, 스마트 포인터와의 조합까지 실무 기준으로 정리합니다.
• C++ 속성(Attributes): [[nodiscard]]·[[deprecated]]·[[likely]]·[[fallthrough]] 실전 사용법[[nodiscard]]로 반환값 무시를 경고하고, [[deprecated]]로 API 교체를 알리며, [[maybe_unused]]·[[fallthrough]]·[[noreturn]]·C++20 [[likely]]를 어디에 붙여야 하는지 에러 처리와 API 마이그레이션 예제로 설명합니다.
• C++ 스마트 포인터 | unique_ptr·shared_ptr·weak_ptr와 순환 참조 끊기Valgrind는 누수가 없다는데 메모리가 계속 늘어나는 shared_ptr 순환 참조를 출발점으로, unique_ptr의 소유권 이전과 커스텀 삭제자, shared_ptr의 참조 카운팅 구조와 비용, weak_ptr로 순환을 끊는 법과 상황별 선택 기준을 다룹니다.
• C++ 시간·타이머·세마포어 유틸리티 지도: 벤치마크, 주기 작업 드리프트, counting_semaphore, 날짜 서식sleep_for로 만든 주기 작업의 누적 드리프트, sleep_until의 보정, counting_semaphore로 동시 실행 수 제한, std::format 날짜 서식을 직접 실행해 확인하고 스톱워치, 타이머, 로케일 글로 연결합니다.
• C++ 연산자 오버로딩: 멤버·비멤버 선택, 산술·비교·입출력 연산자 구현C++ 연산자 오버로딩으로 복소수, 분수, 행렬, 문자열 클래스에 산술·비교·입출력 연산자를 정의하는 방법을 정리합니다. 멤버·비멤버 선택, friend, 자기 대입, const 정확성 함정까지 다룹니다.
• C++ 예외 안전성 Basic·Strong·Nothrow 보장: RAII와 copy-and-swap으로 구현하기예외가 나면 락이 풀리지 않거나 컨테이너가 반쯤 수정된 상태로 남는 문제를 Basic, Strong, Nothrow 세 단계 보장으로 구분하고, RAII 래퍼, copy-and-swap, 트랜잭션 스타일 코드, noexcept 지정으로 원하는 보장 수준을 구현하는 방법을 설명합니다.
• C++ 예외 처리, try-catch와 Error Code 중 뭐가 빠를까함수 호출이 깊어질수록 에러 코드를 계속 전달하기 어려워지는 문제에서 출발해 throw와 try-catch 문법, catch 순서, 표준 예외 계층, RAII로 누수를 막는 법, 예외를 써야 할 때와 피할 때, 재던지기에서 throw;를 써야 하는 이유를 설명합니다.
• C++ 예외 처리: try/catch/throw, 예외 안전성, 언제 예외를 쓰나예외를 던질지 에러 코드를 반환할지 결정하는 기준부터, 예외를 참조로 잡아야 하는 이유, 소멸자에서 던지면 안 되는 이유, RAII로 예외 안전성을 지키는 법, 스택 풀기와 noexcept의 실제 효과까지 C++ 예외 처리를 코드로 짚습니다.
• C++ 오픈소스 기여: 유명 라이브러리 분석부터 첫 Pull Request까지C++ 오픈소스에 기여하고 싶지만 어디서 시작할지 모를 때 프로젝트와 이슈를 고르는 기준부터 spdlog 같은 코드베이스를 빌드·테스트하며 읽는 순서를 보여줍니다. 포크와 브랜치, 커밋 메시지, PR 설명, 리뷰 대응, CLA, 머지 충돌 해결도 다룹니다.
• C++ 임시 객체: 생성·소멸 시점, const 참조 수명 연장 규칙, 댕글링 참조함수 인자 변환, 반환값, 연산자 체이닝 중에 생기는 이름 없는 임시 객체가 언제 만들어지고 언제 소멸되는지 설명합니다. const 참조와 우측값 참조로 수명이 연장되는 규칙, 멤버를 통한 바인딩에서 생기는 댕글링 참조, RVO와 이동으로 비용을 줄이는 법을 다룹니다.
• C++ 작업 큐 설계: 워크 스틸링으로 스레드 풀 성능 끌어올리기메인 스레드에서 무거운 작업을 돌려 UI가 멈추는 문제를 조건 변수 기반 작업 큐와 스레드 풀로 푸는 과정을 구현합니다. std::future로 결과 받기, 부하 불균형을 줄이는 워크 스틸링, spurious wakeup과 shutdown 타이밍, 예외로 워커가 죽는 문제도 다룹니다.
• C++ 전방 선언: 헤더 의존성 줄이기, 불완전 타입의 제약, Pimpl 소멸자 위치class A; 한 줄로 헤더 의존성을 끊어 순환 include를 풀고 재컴파일 범위를 줄이는 전방 선언의 원리를 설명합니다. 불완전 타입으로는 포인터와 참조만 쓸 수 있는 이유와 unique_ptr, Pimpl 패턴에서 소멸자 위치를 조심해야 하는 이유도 다룹니다.
• C++ 전역 변수가 문제를 일으키는 5가지 경우와 대안: 초기화 순서, 스레드 안전성, 테스트C++ 전역 변수의 함정과 대안. 초기화 순서 문제(Static Initialization Order Fiasco), 스레드 안전성, 테스트 어려움, 네임스페이스 오염부터 함수 내 정적 변수·Singleton·DI까지 정리합니다.
• C++ 전처리 지시자: 매크로 부작용, #if·#ifdef 조건부 컴파일, -E로 결과 확인#define 매크로가 인자를 두 번 평가하거나 괄호가 빠져 계산이 틀어지는 부작용을 예제로 보여주고, #if와 #ifdef로 플랫폼별 코드를 나누는 법, 문자열화 연산자, #pragma, 전처리 결과를 -E로 확인하는 방법까지 전처리 지시자를 설명합니다.
• C++ 정적 분석 도구 통합: Clang-Tidy와 Cppcheck로 코드 퀄리티 강제하기C++ 16번 디버깅의 연장선. Clang-Tidy와 Cppcheck를 CI·에디터에 통합해 버그가 발생하기 전에 코드 퀄리티를 강제하는 방법을 다룹니다. Cppcheck 프로젝트 파일, 변경 파일만 검사하는 CI, SonarQube Quality Gate로 신규 코드만 막는 레거시 도입 전략까지 정리했습니다.
• C++ 참조: lvalue·rvalue·const 참조, 참조 vs 포인터, 참조 축약 규칙C++ 참조 정리. 큰 객체를 복사 없이 넘기는 문제에서 출발해 lvalue 참조, rvalue 참조, const 참조, 참조와 포인터의 차이, 참조 축약 규칙과 자주 나는 에러를 예제로 다룹니다.
• C++ 캐스팅 4가지: static_cast·dynamic_cast·const_cast·reinterpret_cast 언제 쓰나C++의 4가지 캐스트(static_cast, dynamic_cast, const_cast, reinterpret_cast)가 각각 언제 안전하고 언제 위험한지, C 스타일 캐스트(T)x가 왜 지양되는지, dynamic_cast 실패를 무시했을 때의 크래시까지 실전 예제로 정리합니다.
• C++ 캐시 교체 알고리즘: FIFO·LRU·LFU·Clock·MRU·OPT 구현과 비교FIFO·LRU·LFU·MRU·Random·Clock·OPT 캐시 교체 정책의 동작 원리와 시간 복잡도를 비교하고, FIFO·LRU·Clock 캐시를 C++로 구현한 뒤 Redis 정책, OS 페이지 교체, CDN의 LFU 변형과 연결해 설명합니다.
• C++ 캐시 친화 코드: AoS vs SoA, 데이터 지향 설계, False SharingC++ 캐시 친화 코드 작성법을 정리합니다. 행 우선 순회, 구조체 패딩과 핫/콜드 분리, AoS vs SoA가 실제로 이득인 경우, false sharing과 Apple Silicon의 128바이트 캐시 라인, 소프트웨어 프리페치, perf stat·perf c2c로 측정하는 법까지 다룹니다.
• C++ 커스텀 예외 클래스 만들기 | 예외 성능과 Zero-Cost Exceptionstd::exception을 상속해 에러 코드와 컨텍스트를 담는 예외 계층을 설계하고, 루프 안에서 예외를 던지면 왜 느려지는지 벤치마크로 확인합니다. zero-cost 예외 모델의 의미, 예외와 에러 코드를 섞는 하이브리드 방식, 예외 슬라이싱 같은 실수도 다룹니다.
• C++ 컨테이너 선택 가이드 | vector/list/deque/map/set 상황별 선택과 성능 최적화앞쪽 삽입을 반복하다 시간 초과가 나는 경우처럼 컨테이너를 잘못 고른 상황에서 출발해 vector·deque·list와 map·set·unordered 계열을 연산 복잡도와 메모리 배치로 비교합니다. BFS·LRU 캐시 예제와 반복자 무효화, 해시 미정의 에러도 다룹니다.
• C++ 코드 커버리지 측정: gcov·lcov 리포트, Google Test 연동, CI에서 Codecov 올리기gcov로 C++ 코드 커버리지를 측정하고 lcov로 HTML 리포트를 만든 뒤 Google Test와 CMake 빌드에 연동하는 과정을 다룹니다. 라인·브랜치·함수·조건·경로 커버리지가 각각 무엇을 보여 주는지와 CI에서 Codecov로 결과를 올리는 흐름도 설명합니다.
• C++ 콜백 구현 4가지 비교: 함수 포인터, 펑터, std::function, 람다와 멤버 함수 콜백C++ 콜백 패턴 정리. 함수 포인터, 펑터, std::function, 람다 네 가지 구현 방법을 비교하고, 비동기 콜백·이벤트 핸들러·Observer 패턴 활용, 콜백 지옥 회피와 성능 고려사항을 다룹니다.
• C++ 클래스 템플릿: 멤버 외부 정의, 부분 특수화, 템플릿 별칭, CTAD로 제네릭 컨테이너 만들기C++ 클래스 템플릿 작성법. 기본 문법, 멤버 함수 외부 정의(헤더 또는 명시적 인스턴스화), 부분 특수화, using 템플릿 별칭, CTAD(C++17), 제네릭 컨테이너 예제와 자주 나는 에러를 정리합니다.
• C++ 클래스·링크·메모리 문제를 증상으로 찾는 표: Rule of Five, EBCO, 다이아몬드, 이름 맹글링, use-after-free복사 때 이중 해제, 객체 크기가 예상보다 큼, 기본 클래스가 두 번 생성됨, 링크 에러의 _Z 심볼, 해제 후 사용 같은 증상을 실행 결과로 보여 주고 원인과 자세한 글을 연결합니다.
• C++ 타입 변환: 암시적 변환, static_cast·dynamic_cast·const_cast·reinterpret_cast, explicitC++ 타입 변환 정리. 암시적 변환과 명시적 변환, static_cast·dynamic_cast·const_cast·reinterpret_cast의 용도와 차이, 변환 생성자와 explicit, 변환 연산자를 예제로 다룹니다.
• C++ 템플릿 기초: 함수·클래스 템플릿, 가변 인자, SFINAE에서 Concepts까지타입마다 복사하던 함수를 template<typename T>로 합치는 것부터 시작해 타입 추론 규칙과 max(3, 3.14)가 실패하는 이유, 템플릿 링크 에러, 가변 인자 템플릿과 fold expression, 특수화, SFINAE와 Concepts까지 단계적으로 설명합니다.
• C++ 템플릿 특수화: 모든 타입에 같은 로직을 쓸 수 없을 때 완전·부분 특수화로 푸는 법bool만 true/false로 출력하고 싶을 때처럼 타입마다 다른 동작이 필요할 때 완전 특수화와 부분 특수화를 어떻게 나눠 쓰는지 예제로 보여줍니다. 함수 템플릿은 왜 부분 특수화 대신 오버로드를 써야 하는지, ODR 위반과 모호성 에러도 다룹니다.
• C++ 파일 입출력: ifstream·ofstream 기초부터 에러 처리, 버퍼링, 원자적 쓰기까지C++ 파일 입출력 정리. ifstream·ofstream·fstream으로 읽고 쓰기, 에러 처리와 스트림 상태 확인, 버퍼링과 flush, 임시 파일과 rename을 이용한 원자적 쓰기, 한글 경로 처리를 다룹니다.
• C++ 패키지 관리 실무: vcpkg와 Conan으로 외부 라이브러리 의존성 지옥 탈출헤더 하나 쓰려다 경로 설정에 막히는 의존성 문제를 vcpkg와 Conan으로 푸는 실무 방법을 다룹니다. vcpkg 오버레이 포트와 버전 제약, Conan 프로필·옵션·lockfile을 설명하고 CI, 멀티 플랫폼, 사내 저장소, Docker 환경에서 쓰는 패턴을 비교합니다.
• C++ 프로젝트 CI 구성: GitHub Actions 멀티 OS·컴파일러 매트릭스, vcpkg 캐시, 테스트로컬에선 되는데 CI에서만 실패하는 C++ 프로젝트를 위한 GitHub Actions 구성. 멀티 OS·컴파일러 매트릭스, CMake 빌드, vcpkg·Conan 캐시, 테스트 실행과 최적화 팁을 다룹니다.
• C++ 프로파일링: perf·Tracy·VTune 도구 비교와 병목 찾는 절차추측으로 최적화하다 시간을 날리지 않도록 std::chrono 측정에서 시작해 perf, gprof, Callgrind, Tracy, VTune 같은 도구로 핫스팟을 찾는 절차를 보여줍니다. Flame Graph 생성, 측정과 재측정을 반복하는 흐름, 벤치마크할 때 빠지기 쉬운 함정도 다룹니다.
• C++ 함수 객체(펑터): 상태를 가진 호출 객체, STL 알고리즘 활용, 람다와의 차이operator()를 오버로드한 함수 객체가 호출 사이에 상태를 유지하는 방법과 STL 알고리즘에서 쓰는 법을 설명하고, operator()의 const 누락, const를 지키면서 상태를 바꿔야 할 때의 mutable, 큰 펑터의 복사 비용을 std::ref로 줄이는 법을 예제로 다룹니다.
• C++ 현대적 다형성 설계: 상속 대신 합성·variantdynamic_cast가 늘어나는 이벤트 시스템이나 여러 결제 수단처럼 상속이 부담스러워지는 경우를 합성과 std::variant로 다시 설계하는 방법을 보여줍니다. overloaded 헬퍼와 std::visit, 설계 선택 흐름, bad_variant_access 같은 에러도 다룹니다.
• C++ 현대적인 GUI: Dear ImGui로 디버깅 툴·대시보드 만들기콘솔 출력만 보던 프로그램에 Dear ImGui로 디버깅 창을 띄우는 방법을 즉시 모드 개념부터 설명하고, GLFW + OpenGL 백엔드 연동과 CMake 빌드를 전체 예제로 보여줍니다. 모니터링 대시보드와 Begin/End 불일치, 한글 깨짐 문제도 다룹니다.
• C++ atomic: 락 없는 카운터, 메모리 순서, 언제 mutex 대신 쓰나카운터 하나에 mutex를 쓰기 부담스러울 때 std::atomic의 fetch_add와 compare_exchange로 락 없이 갱신하는 방법, seq_cst, acquire/release, relaxed 메모리 순서를 고르는 기준, 스핀락과 플래그 같은 활용 패턴, ABA 문제와 volatile 혼동을 설명합니다.
• C++ auto와 decltype: 타입 추론 규칙, decltype(auto), AAA 스타일auto가 const와 참조를 떼어내는 규칙, auto&&와 전달 참조, 중괄호 초기화 추론처럼 헷갈리는 타입 추론 규칙을 예제로 확인합니다. decltype이 변수 이름과 표현식에서 다르게 동작하는 이유, decltype(auto)로 참조 반환을 보존하는 법과 AAA 스타일도 다룹니다.
• C++ Bridge 패턴: 추상화와 구현을 분리해 클래스 폭발 막기 (렌더러·플랫폼 교체 예제)C++ Bridge 패턴으로 구현(Implementor)과 추상화(Abstraction)를 분리해 플랫폼·드라이버를 바꿔 끼우는 방법. 렌더러 교체, 플랫폼 독립 설계, 크로스 플랫폼 윈도우 시스템 예제를 정리합니다.
• C++ Command 패턴: 요청을 객체로 만들어 Undo/Redo·매크로·트랜잭션 구현하기C++에서 요청을 Command 객체로 감싸 Undo/Redo 히스토리 스택, 매크로 기록, All-or-Nothing 트랜잭션을 구현합니다. std::function으로 충분한 경우와 객체가 필요한 경우를 가르고, 텍스트 에디터 전체 예제로 구조를 확인합니다.
• C++ Composite 패턴: 파일 시스템·UI 트리를 하나의 인터페이스로 다루기Composite 패턴으로 파일과 폴더, GUI 위젯, 조직도를 같은 인터페이스로 다루는 방법을 C++로 구현합니다. Leaf에 add()를 호출하는 문제, 순환 참조와 메모리 누수, Visitor·Iterator와 결합하는 패턴도 설명합니다.
• C++ condition_variable로 작업 큐 만들기: 허위 깨움 처리와 스레드 풀작업 큐를 폴링하며 CPU를 낭비하던 구조를 condition_variable로 바꿔 작업이 들어올 때만 스레드를 깨우는 방법을 설명합니다. predicate를 넣은 wait로 허위 깨움을 처리하는 법, 스레드 안전 큐와 스레드 풀 구현, lock_guard를 쓰면 안 되는 이유를 다룹니다.
• C++ constexpr 함수: 컴파일 타임 평가 조건과 C++11·14·17 제약 변화constexpr 함수가 상수 표현식 문맥에서만 컴파일 타임에 평가되는 규칙을 설명하고, C++11의 단일 return 제약에서 C++14·C++17로 완화된 내용, constexpr 클래스, 정적 변수·가상 함수 사용 시 생기는 오류를 예제로 다룹니다.
• C++ Decorator 패턴: 상속 대신 감싸서 기능 붙이기 (스트림·로깅·포매터 예제)C++ Decorator 패턴으로 상속 없이 객체를 감싸 기능을 덧붙이는 방법을 스트림 데코레이터, 로깅 시스템, 텍스트 포매터 예제로 구현하고, 빌더 스타일로 여러 데코레이터를 조합하는 패턴을 설명합니다.
• C++ emplace_back vs push_back: 실제 성능 차이와 언제 다른지emplace_back은 인자를 받아 컨테이너 안에서 바로 객체를 생성하고, push_back은 이미 만든 객체를 복사하거나 이동합니다. 단순 타입과 복잡한 객체 벤치마크로 실제 차이가 언제 생기는지 확인하고, map·set에서의 emplace 사용도 다룹니다.
• C++ enum class: 밑바닥 타입, 비트 플래그, 문자열 변환 패턴C++11 enum class의 스코프와 암시적 변환 차단, 밑바닥 타입과 ABI·직렬화, 문자열 변환 패턴, 비트 플래그 연산자 오버로딩, 범위 밖 정수 캐스팅과 Windows ERROR 매크로 충돌 같은 함정을 예제로 정리합니다.
• C++ explicit 키워드: 암시적 변환 막기, explicit operator bool, C++20 explicit(bool)explicit를 붙이면 복사 초기화와 함수 인자에서 일어나던 암시적 변환이 막힙니다. 생성자와 변환 연산자, explicit operator bool, C++20 조건부 explicit(bool)의 동작을 비교하고, 스마트 포인터와 단위 타입에서 explicit를 쓰는 패턴을 정리합니다.
• C++ extern과 링키지: 전역 변수 공유, 내부·외부 연결, C 함수 연동전역 변수를 여러 .cpp에서 공유하려면 헤더에는 extern 선언만, 정의는 한 파일에만 두어야 합니다. 내부·외부 연결의 차이, extern과 static 비교, const 전역의 기본 링키지, extern "C"로 C 라이브러리와 연동하는 방법을 예제로 봅니다.
• C++ Factory 패턴 비교: Simple Factory, Factory Method, Abstract Factory, 자동 등록C++ Factory 패턴으로 객체 생성을 캡슐화하는 방법. Simple Factory, Factory Method, Abstract Factory의 차이, 자동 등록 팩토리, 플러그인 시스템 예제를 정리합니다.
• C++ filesystem::path: 경로 결합·분해, absolute·canonical·relative 차이std::filesystem::path의 / 연산자로 경로를 결합하고 filename, stem, extension으로 부분을 추출하는 법, absolute, canonical, relative의 차이, 확장자 일괄 변경과 백업 경로 생성 예제로 Windows와 Linux에서 같은 코드가 동작하게 만드는 방법을 다룹니다.
• C++ filesystem::status로 파일 종류·권한·수정 시간 확인하기std::filesystem::status와 symlink_status가 반환하는 file_status로 파일 종류와 권한을 확인하는 방법, perms 비트 검사, 수정 시간과 디스크 공간 조회, 심볼릭 링크와 존재 확인에서 생기는 함정을 예제로 다룹니다.
• C++ Flyweight 패턴: 공통 상태를 공유해 텍스트·타일·파티클 메모리 줄이기C++ Flyweight 패턴으로 공통 상태(intrinsic)를 공유하고 개별 상태(extrinsic)만 따로 두어 메모리를 줄이는 방법. 텍스트 렌더링, 게임 타일, 파티클 시스템 예제와 캐시 수명·동시성 문제를 다룹니다.
• C++ Google Test | gtest 설치부터 TEST·EXPECT_EQC++ Google Test(gtest) 단위 테스트 가이드. FetchContent·vcpkg 설치, TEST·TEST_F·EXPECT·ASSERT·파라미터화·Death Test, TDD·프로덕션 패턴, CI 연동, 자주 나는 오류 해결.
• C++ HTTP 클라이언트 직접 만들기: TCP 소켓부터 Boost.Beast, 연결 풀, 타임아웃까지C++로 HTTP 클라이언트를 구현하는 방법. HTTP 기초와 TCP 연결, Boost.Beast로 REST API 호출하기, 연결 풀과 Keep-Alive, 타임아웃 처리, 자주 나는 에러와 성능 벤치마크를 다룹니다.
• C++ inline의 진짜 의미: 인라인 확장이 아니라 ODR 예외, inline 변수와 constexprinline은 호출을 펼치라는 명령이 아니라 헤더에 정의를 두어도 링크 에러가 나지 않게 하는 ODR 예외입니다. 실제 인라인 확장은 컴파일러가 결정한다는 점, 큰 함수와 재귀·가상 함수의 한계, C++17 inline 변수와 constexpr의 관계를 예제로 봅니다.
• C++ JSON 파싱: nlohmann/json vs RapidJSON, 커스텀 타입 직렬화, null·타입 에러 처리C++ REST API 응답·설정 파일 파싱 시 타입 에러·null 접근·메모리 폭발 문제를 해결합니다. nlohmann/json, RapidJSON, 커스텀 타입 직렬화, 자주 발생하는 에러와 API 응답 처리 패턴을 예제 코드로 다룹니다.
• C++ make_heap·push_heap·pop_heap: priority_queue 대신 힙을 직접 다룰 때std::make_heap·push_heap·pop_heap·sort_heap으로 벡터를 직접 힙으로 관리하는 방법, 최대 힙과 최소 힙을 만드는 비교자, priority_queue와 비교한 장단점, Top-K 추출과 힙 정렬 구현을 예제로 설명합니다.
• C++ make_unique·make_shared: new보다 나은 이유와 make 함수를 쓰면 안 되는 경우make_unique와 make_shared가 new보다 예외에 안전한 이유, make_shared가 객체와 제어 블록을 한 번에 할당해서 얻는 이점과 weak_ptr이 남아 있을 때 메모리가 늦게 해제되는 단점, 커스텀 삭제자나 private 생성자처럼 make 함수를 쓸 수 없는 경우를 설명합니다.
• C++ malloc vs new vs make_unique: 메모리 할당 방식별 안전성 비교C++ malloc, new, make_unique를 생성자 호출·타입 안전성·실패 처리(nullptr, bad_alloc, nothrow)·예외 안전성으로 비교하고, 속도 차이가 거의 없는 이유와 벤치마크가 0ms로 나오는 이유까지 정리합니다.
• C++ map·unordered_map·flat_map: 성능 비교와 선택 기준std::map(레드-블랙 트리), unordered_map(해시 테이블), C++23 flat_map의 내부 구조 차이가 검색·삽입 성능에 어떻게 드러나는지 비교합니다. lower_bound 범위 검색, 커스텀 키의 해시 함수, operator[]가 원소를 몰래 만드는 문제와 선택 기준을 다룹니다.
• C++ Move Semantics | std::move로 불필요한 복사 제거하기큰 vector를 반환할 때의 복사 비용에서 출발해 lvalue·rvalue 구분, rvalue 참조, 이동 생성자와 이동 대입, Rule of Five를 예제로 구현합니다. return std::move가 RVO를 막는 경우, noexcept 누락, const 객체에 move를 거는 실수도 다룹니다.
• C++ mutable: const 멤버 함수에서 캐시·카운터·mutex를 수정하는 경우와 남용 주의const 멤버 함수 안에서도 캐시, 통계 카운터, mutex처럼 객체의 논리적 상태와 무관한 멤버를 수정할 수 있게 하는 mutable의 쓰임새와, const_cast와의 차이, 람다의 mutable, 남용했을 때 생기는 문제를 예제로 설명합니다.
• C++ mutex: 경쟁 상태, 데드락, lock_guard·scoped_lock 사용 원칙주문 수가 맞지 않는 카운터 버그로 race condition과 data race를 구분하고, 재고 감소나 작업 큐 중복 처리 같은 사례를 mutex로 고칩니다. lock_guard와 unique_lock 선택 기준, 락 순서 통일과 std::lock, scoped_lock으로 데드락을 피하는 법도 설명합니다.
• C++ namespace 심화: using 선언 vs 지시문, 익명 namespace, 인라인 namespace, ADLC++ namespace의 using 선언과 지시문 차이, 익명 namespace와 파일 범위 static 비교, 별칭, 인라인 namespace를 이용한 버전 관리, ADL과 swap 관용구, 헤더에서 피해야 할 패턴과 프로젝트 구조에 맞춘 배치를 설명합니다.
• C++ next_permutation으로 순열·조합 만들기: 정렬 후 do-while 패턴next_permutation과 prev_permutation으로 사전순 순열을 만드는 방법을 설명하고, 정렬부터 하고 do-while로 돌리는 패턴, 문자열 순열, n개 중 k개 순열과 조합 생성, 완전 탐색에 적용하는 예제를 다룹니다.
• C++ nlohmann/json 실전: 파싱·커스텀 타입 직렬화·에러 처리와 자주 틀리는 동작nlohmann/json으로 JSON을 파싱하고 구조체와 변환하는 방법, operator[]·value()·at()의 차이, 키 순서가 바뀌는 이유와 ordered_json, float→int 무음 변환, SAX 파싱, simdjson·RapidJSON과 고르는 기준까지 정리합니다.
• C++ noexcept 지정자: 이동 생성자·swap·소멸자에 붙이는 이유와 위반 시 terminateC++ noexcept 지정자로 함수가 예외를 던지지 않음을 명세하는 방법을 이동 생성자, swap, 소멸자, vector 최적화 예제로 정리합니다. 조건부 noexcept, noexcept 연산자, 위반 시 std::terminate 함정까지 다룹니다.
• C++ Observer 패턴: weak_ptr로 구독자 수명 관리, 이벤트 타입별 알림, 신호/슬롯C++ Observer 패턴으로 이벤트 기반 구조를 만드는 방법. 기본 구조, weak_ptr로 댕글링과 누수 방지, 이벤트 타입별 Observer, 신호/슬롯 패턴, 주식 시장 모니터 예제를 정리합니다.
• C++ partition·stable_partition·partition_point: 조건으로 범위 나누기std::partition으로 조건에 맞는 요소를 앞쪽으로 모으고, 상대 순서를 지키는 stable_partition과 비교하며, 분할된 범위에서 partition_point로 경계를 이진 탐색하는 방법과 3-way 분할, 퀵 정렬 한 단계 스케치를 다룹니다.
• C++ Proxy 패턴: 가상·보호·캐싱 프록시로 지연 로딩과 접근 제어 구현하기무거운 객체를 실제로 필요할 때 만드는 가상 프록시, 권한을 확인한 뒤 호출을 넘기는 보호 프록시, 결과를 저장해 두는 캐싱 프록시를 C++로 구현하고, 스마트 포인터와 Copy-on-Write가 프록시의 한 형태인 이유를 데이터베이스 연결 예제로 설명합니다.
• C++ RAII: 생성자에서 획득하고 소멸자에서 해제하는 자원 관리 클래스 만들기early return 때문에 파일 핸들이 새는 코드에서 시작해, 생성자에서 획득하고 소멸자에서 해제하는 RAII로 파일, 뮤텍스, 소켓, DB 트랜잭션을 관리하는 클래스를 직접 만들고 복사와 이동 규칙을 정하는 방법을 보여줍니다.
• C++ remove·remove_if가 원소를 지우지 않는 이유: erase-remove와 C++20 erase_ifstd::remove와 remove_if가 실제로 요소를 지우지 않고 뒤로 밀어 내기만 하는 이유를 설명하고, erase-remove 관용구, 정렬 후 unique로 중복 제거하는 방법, C++20 std::erase·erase_if로 간결하게 쓰는 법을 다룹니다.
• C++ REST API 클라이언트: cpr·cpp-httplib·libcurl 비교, 인증, 재시도와 서킷 브레이커C++ REST API 클라이언트 구현. cpr(C++17 libcurl 래퍼), cpp-httplib(헤더 온리), libcurl의 선택 기준, CRUD와 Bearer·API 키 인증, 재시도·서킷 브레이커 같은 에러 처리 패턴을 다룹니다.
• C++ Rule of Five 직접 구현하기: copy-and-swap, 자기 대입, noexcept 이동 연산동적 배열, 파일 핸들, 문자열 클래스를 직접 만들며 소멸자, 복사·이동 생성자, 복사·이동 대입 연산자를 언제 함께 정의해야 하는지 보여줍니다. 자기 대입과 예외 안전성을 copy-and-swap으로 해결하는 법, 이동 연산의 noexcept 누락 문제도 다룹니다.
• C++ Sanitizer 동작 원리와 설정: ASan·UBSan·TSan·MSan 오버헤드, CMake 통합use-after-free를 잡는 ASan, 데이터 레이스를 잡는 TSan, 미정의 동작을 잡는 UBSan, 초기화 안 된 메모리를 잡는 MSan이 각각 어떻게 동작하고 얼마나 느려지는지, ASan·TSan을 함께 못 쓰는 이유와 CMake 프리셋·CI job 분리 방법을 설명합니다.
• C++ Segmentation fault 디버깅: core dump·GDB·LLDB·ASan·Valgrind로 원인 찾기프로덕션에서 가끔만 나는 Segmentation fault를 추적하려고 core dump를 남기고 GDB·LLDB로 백트레이스를 읽는 절차를 보여줍니다. null 역참조, use-after-free, 스택 오버플로우, 버퍼 오버런을 ASan·Valgrind로 잡는 예제도 다룹니다.
• C++ set_union·set_intersection·set_difference: 정렬된 범위의 집합 연산정렬된 범위에서 set_union·set_intersection·set_difference·set_symmetric_difference로 합·교·차집합을 구하고 includes로 포함 관계를 검사하는 방법을 권한 관리, 태그 필터링, 변경 사항 추적 예제로 설명합니다.
• C++ shared_ptr 순환 참조와 weak_ptr: 부모-자식·옵저버·그래프·캐시에서 끊는 법shared_ptr끼리 서로를 가리켜 참조 카운트가 0이 되지 않는 순환 참조를 캐릭터-길드, 부모-자식 트리, 옵저버, 그래프, 리소스 캐시 예제로 재현하고 weak_ptr로 끊는 방법을 보여줍니다. lock()과 expired()의 올바른 사용, enable_shared_from_this 실수, 누수 진단 방법도 다룹니다.
• C++ sregex_iterator·sregex_token_iterator: 모든 매치 순회와 문자열 분할문자열 안의 모든 정규식 매치를 sregex_iterator로 순회하며 캡처 그룹을 꺼내고, sregex_token_iterator로 구분자 기준 분할을 하는 방법을 단어 추출, URL 파싱, 로그 파싱 예제로 보여줍니다. 임시 문자열 수명, 빈 매치, 성능 함정도 다룹니다.
• C++ State 패턴: 조건문 폭발을 상태 객체로 바꾸기 (TCP·게임 AI·자판기 예제)C++ State Pattern으로 조건문 폭발을 막는 방법을 TCP·게임 AI·자판기 예제로 설명합니다. Strategy와의 차이, 상태 객체 재사용 트레이드오프, 전이 중 자기 삭제 같은 자주 만나는 함정까지 정리했습니다.
• C++ static_assert: 타입 크기·템플릿 제약·구조체 레이아웃을 컴파일 시점에 검증하기static_assert로 타입 크기, 템플릿 인자 제약, 플랫폼 조건, 구조체 레이아웃을 컴파일 시점에 검증하는 방법을 다룹니다. NDEBUG에 영향받는 assert와의 차이, 런타임 값을 넣었을 때의 에러, 템플릿에서 검사가 언제 일어나는지도 설명합니다.
• C++ std::any vs void*: 타입 안전성·크기·성능 비교와 void*가 필요한 곳임의의 타입을 저장해야 할 때 void*와 std::any 중 무엇을 쓸지 타입 안전성, 메모리 크기, 성능 기준으로 비교하고, 설정 저장소·이벤트 시스템·플러그인 예제와 C 라이브러리 인터페이스에서의 void* 사용법을 다룹니다.
• C++ std::async와 launch 정책: future, deferred 실행, 흔한 함정std::async에 launch::async와 launch::deferred를 지정했을 때 실행 시점이 어떻게 달라지는지 설명하고, 여러 future 결과 모으기, 예외 전달, wait_for로 상태 확인과 타임아웃 처리, 병렬 다운로드·맵 리듀스 예제를 다룹니다.
• C++ std::bind와 placeholders: 부분 적용, 멤버 함수 바인딩, 람다로 바꿀 때std::bind로 함수 인자를 미리 고정하는 부분 적용, placeholders로 인자 순서를 바꾸는 방법, 멤버 함수 바인딩, 이벤트 핸들러와 콜백 시스템 예제를 설명하고, 같은 일을 람다로 옮겼을 때와 비교합니다.
• C++ std::function | 콜백·전략 패턴과 함수 객체버튼 클릭 핸들러처럼 실행할 함수를 변수에 담아야 할 때 std::function으로 일반 함수·람다·멤버 함수·함수 객체를 저장하는 방법을 다룹니다. 상태를 가진 functor, std::bind와 람다 비교, 전략·명령 패턴 구현, 빈 function 호출과 dangling 캡처 오류도 설명합니다.
• C++ std::function vs 함수 포인터: 성능과 유연성의 트레이드오프콜백을 저장할 때 함수 포인터와 std::function 중 무엇을 고를지 비교합니다. 호출 한 번의 비용 차이는 간접 호출 한 단계 정도이고, 실제 비용은 인라인 불가와 생성·복사 시 힙 할당에서 생긴다는 점을 이벤트 시스템·스레드 풀 예제로 설명합니다.
• C++ std::locale과 facet: 숫자·통화·날짜를 지역 형식으로 출력하기std::locale과 facet으로 숫자 천 단위 구분, 통화, 날짜 출력을 지역에 맞게 바꾸고 isalpha 같은 문자 분류를 locale 기준으로 처리하는 방법을 예제로 보여 주며, 시스템에 locale이 설치되지 않았을 때의 예외도 다룹니다.
• C++ std::optional vs 포인터: 값이 없을 수 있는 반환값을 어떻게 표현할까값이 없을 수 있는 반환값이나 선택적 매개변수를 nullptr 포인터 대신 std::optional로 표현하면 무엇이 안전해지는지 비교합니다. 반대로 다형성이나 큰 객체를 소유하지 않고 참조할 때는 왜 포인터가 맞는지 메모리 레이아웃과 벤치마크로 설명합니다.
• C++ std::ratio: 컴파일 타임 분수 연산과 chrono 단위 표현 원리std::ratio로 분수를 타입에 담아 ratio_add, ratio_multiply 같은 연산과 약분을 컴파일 타임에 끝내는 방법, chrono::duration이 milli와 micro로 단위를 표현하는 원리를 보여주고, 단위 변환과 프레임 레이트 예제, 연산 중 오버플로우 문제를 다룹니다.
• C++ std::regex 실전: regex_match vs regex_search, 캡처 그룹, 토큰화와 탐욕적 매칭 함정C++ std::regex로 문자열 검증, URL 파싱, 로그 분석, 치환, 토큰화를 구현하는 방법을 정리합니다. regex_match/search 차이, 캡처 그룹, 이스케이프, 성능, 탐욕적 매칭 함정까지 다룹니다.
• C++ std::thread와 jthread 기초: 생성, join·detach, 공유 데이터 보호std::thread에 함수, 람다, 인자를 넘기는 법과 std::ref가 필요한 이유, join과 detach로 수명을 관리하는 법, 예외가 나도 스레드를 정리하는 ThreadGuard와 C++20 jthread, mutex와 condition_variable 기초까지 멀티스레딩의 첫 단계를 다룹니다.
• C++ std::tuple: 여러 값 반환, std::tie와 구조적 바인딩, 구조체와 비교std::tuple로 여러 값을 한 번에 반환하고 std::get, 구조적 바인딩, std::tie로 꺼내는 방법을 비교합니다. tie를 이용한 사전식 비교와 정렬, tuple_cat과 std::apply 활용, pair 대신 tuple을 쓸지 구조체를 쓸지 판단하는 기준도 다룹니다.
• C++ std::variant vs union: 타입 안전성과 비용 비교C++ union이 활성 멤버를 추적하지 않아 생기는 문제와 std::variant가 이를 해결하는 방식을 비교하고, std::visit와 overloaded 패턴으로 타입별 처리를 작성하는 방법, JSON 값·AST 노드·에러 처리 예제를 다룹니다.
• C++ STL 고급 알고리즘: partition·merge·집합 연산·힙 연산 쓰는 법과 흔한 실수partition과 stable_partition으로 조건 분할하기, 정렬된 두 범위를 merge와 set_union·set_intersection으로 합치고 교집합 구하기, make_heap·push_heap으로 우선순위 큐를 직접 다루는 법을 예제로 정리하고, 정렬되지 않은 입력을 넘기는 실수 같은 함정을 짚습니다.
• C++ Strategy 패턴: 다형성 vs 함수 포인터 vs 람다 vs std::function으로 알고리즘 교체하기C++ Strategy 패턴으로 알고리즘을 캡슐화하고 런타임에 교체하는 방법. 다형성, 함수 포인터, 람다, std::function 네 가지 구현과 각각의 성능 특성, 압축 알고리즘 예제를 정리합니다.
• C++ string vs string_view: 복사 없는 문자열 처리와 선택 기준읽기 전용 문자열을 인자로 받을 때 std::string_view가 복사와 할당을 어떻게 줄이는지, 소유와 수정이 필요할 때는 왜 std::string이어야 하는지 비교합니다. 부분 문자열, 파싱, 로깅 예제와 함께 마이크로벤치마크를 읽을 때의 함정도 짚습니다.
• C++ stringstream | 문자열 파싱·변환·포맷팅“123abc”를 int로 바꾸다 실패하는 문제에서 시작해 istringstream으로 공백·CSV 데이터를 안전하게 파싱하고 ostringstream으로 문자열을 조립하는 법을 다룹니다. 매니퓰레이터 상태가 다음 출력에 남는 함정, 스트림 재사용 문제, C++20 std::format과의 비교도 포함합니다.
• C++ thread_local: 스레드별 카운터·버퍼, 초기화 시점과 소멸 순서thread_local 변수는 이름은 하나지만 스레드마다 별도 메모리에 존재해 락 없이 스레드별 카운터·버퍼·난수 생성기를 만들 수 있습니다. 스레드 시작 시와 첫 사용 시 초기화 차이, 클래스 멤버 선언 방법, 소멸 순서와 메모리 사용량 함정을 다룹니다.
• C++ use-after-free: 해제 후 사용이 생기는 패턴과 ASan·gdb로 추적하기delete 후 포인터 사용, 지역 변수를 가리키는 참조 반환, 벡터 재할당으로 무효화된 반복자, 람다가 캡처한 소멸된 객체처럼 Use After Free가 생기는 패턴을 예제로 보여줍니다. ASan과 gdb로 추적하는 법과 스마트 포인터로 막는 법도 다룹니다.
• C++ vector 성능: 캐시 친화성, 용량 성장 전략, reserve 최적화push_back만 반복했는데 느려지는 이유를 size와 capacity, 재할당 비용, 캐시 지역성으로 풀어 보고 reserve·shrink_to_fit·emplace_back을 쓸 시점을 가립니다. string의 SSO, erase-remove, 반복자 무효화 같은 흔한 실수도 다룹니다.
• C++ volatile의 정확한 의미: MMIO 레지스터, ISR 공유 변수, std::atomic과의 차이C++ volatile의 의미, 메모리 맵 I/O(MMIO), 인터럽트 서비스 루틴(ISR), volatile vs std::atomic 차이, 자주 하는 실수, 프로덕션 패턴까지. 릴리스 빌드에서 사라지는 하드웨어 접근 문제 해결.
• C++ vs Go: 성능, 동시성 모델, 프로젝트별 선택 기준C++로 웹 API를 만들다 개발 속도가 밀리거나 Go로 지연에 민감한 시스템을 만들다 GC가 문제가 되는 선택 실패 사례를 두고 두 언어를 비교합니다. 스레드·이벤트 루프와 고루틴 M:N 스케줄링, 컨텍스트 스위칭 비용, CPU 바운드 성능을 다룹니다.
• C++11 중괄호 초기화: narrowing 방지, Most Vexing Parse, vector<int>{10}과 (10)의 차이C++11 중괄호 초기화가 기본 타입, 배열, 구조체, 컨테이너를 같은 문법으로 초기화하면서 narrowing 변환을 컴파일 에러로 막고 Most Vexing Parse를 피하는 방식을 설명합니다. vector<int>{10}과 (10)이 다른 이유, auto와 함께 쓸 때의 함정도 다룹니다.
• C++17 optional·variant·any: nullptr 체크 대신 타입으로 표현하기값이 없을 수 있는 결과는 nullptr 대신 std::optional로, 여러 타입 중 하나는 std::variant와 std::visit으로, 임의 타입은 std::any로 표현하는 방법을 비교합니다. 빈 optional 접근, 잘못된 get·any_cast 같은 흔한 실수도 짚습니다.
• C++17 scoped_lock: 여러 뮤텍스를 데드락 없이 잠그기와 lock_guard·unique_lock 비교계좌 이체처럼 두 뮤텍스를 잠가야 할 때 순서가 엇갈려 생기는 데드락을 std::scoped_lock 한 줄로 피하는 방법과, lock_guard, unique_lock과의 차이, C++11에서 std::lock으로 같은 효과를 내는 법, 잠금 순서 규칙을 예제로 설명합니다.
• C++17 shared_mutex: 읽기-쓰기 락으로 동시 읽기 허용하기와 쓰기 기아읽기가 대부분인 캐시나 설정 관리자에서 std::mutex 대신 C++17 shared_mutex를 쓰면 shared_lock으로 여러 스레드가 동시에 읽을 수 있습니다. unique_lock과의 차이, 캐시·통계 수집기 예제, 쓰기 기아와 락 업그레이드 데드락을 다룹니다.
• C++17 std::invoke와 std::apply: INVOKE 규칙과 튜플을 인자로 펼치는 원리std::invoke가 자유 함수, 멤버 함수 포인터, 함수 객체를 한 문법으로 호출하는 INVOKE 규칙과 std::apply가 index_sequence로 튜플을 풀어 인자로 넘기는 원리를 설명하고, make_from_tuple과 invoke_result·is_invocable 검사를 예제로 다룹니다.
• C++20 날짜 파싱과 서식: std::format·chrono::parse·zoned_time 사용법C++20 std::format과 std::chrono::parse로 날짜·시간을 출력하고 파싱하는 방법. 서식 지정자, 파싱 실패 처리, zoned_time 시간대 변환, 로그 타임스탬프 예제까지 정리합니다.
• C++20 삼원 비교 연산자 <=>: strong·weak·partial_ordering 고르는 기준과 = defaultC++20 <=> 연산자 하나로 <, <=, >, >=를 생성하는 방법과 strong·weak·partial_ordering 중 반환 타입을 고르는 기준을 설명합니다. = default의 사전식 비교, 대소문자 무시 같은 커스텀 비교, ==가 따로 생성되는 규칙도 다룹니다.
• C++20 counting_semaphore·binary_semaphore: 동시 사용 수 제한과 스레드 간 신호C++20 counting_semaphore로 연결 풀이나 워커 슬롯의 동시 사용 수를 제한하고, binary_semaphore로 스레드 간 신호를 보내는 방법을 생산자-소비자 예제로 설명합니다. release 누락, 초기값 실수, try_acquire로 대기 없이 시도하는 법도 다룹니다.
• C++20 std::jthread: 자동 join과 stop_token으로 스레드 협조적 중단하기C++20 std::jthread가 소멸 시 자동으로 join하는 방식과 stop_token·stop_source·stop_callback으로 스레드를 협조적으로 중단하는 방법을 std::thread와 비교하고, 중단 체크 누락이나 detach 같은 실수를 예제로 짚습니다.
• C++20 std::ranges 알고리즘: projection으로 중복 줄이기와 concept 기반 에러C++20 std::ranges 알고리즘을 다룹니다. std::sort 대비 안전성, projection으로 코드 중복 줄이기, concept 기반 컴파일 에러, subrange 반환까지 실전 예제로 정리합니다.
• C++20 std::span 심화: 정적·동적 extent, subspan, 읽기 전용 뷰C++20 std::span의 동적 크기와 정적 크기(extent) 차이, subspan·first·last로 부분 범위를 자르는 법, span<const T>로 읽기 전용 뷰를 만드는 법을 행렬 연산·슬라이딩 윈도우·이미지 처리 예제로 익힙니다. 임시 객체로 생기는 댕글링 span도 짚습니다.
• C++20 stop_token·stop_source·stop_callback: jthread와 협력적 취소 구현C++20 std::stop_token·stop_source·stop_callback과 std::jthread로 협력적 취소를 구현하는 방법입니다. 워커 루프, condition_variable_any 연동, 콜백 수명 주의점을 실전 코드와 함께 설명합니다.
• C++23에서 실제로 쓸 기능: std::expected, mdspan, deducing this, auto(x)C++23 주요 기능 정리. 예외 없이 에러를 다루는 std::expected, 다차원 배열 뷰 mdspan, CRTP를 대체하는 deducing this, auto(x) decay-copy, assume 속성과 C++20/17에서의 마이그레이션을 다룹니다.
• C++26 프리뷰: Reflection과 신규 표준 라이브러리 제안들 [#44-1]구조체가 바뀔 때마다 to_json·from_json을 다시 쓰는 문제를 C++26 Reflection(P2996)이 어떻게 줄이는지 멤버 순회와 splice 예제로 살펴봅니다. std::execution의 sender/receiver 모델, Contracts, 표준에 들어가지 않은 기능도 짚습니다.
• C++로 자료구조 직접 구현하기: 연결 리스트·이진 탐색 트리·해시 테이블·스택·큐C++로 연결 리스트, 이진 탐색 트리, 해시 테이블, 스택, 큐를 직접 구현하며 노드 연결과 삽입·삭제가 내부에서 어떻게 일어나는지 설명하고, LRU 캐시와 인접 리스트 그래프 예제로 응용합니다.
• C++로 작은 DB 엔진 만들기: Pager·B-Tree 저장 엔진, SQL 파서, 실행기, WAL 트랜잭션페이지 기반 Pager, B-Tree 인덱스, SQL 토크나이저/파서, 실행기, WAL 트랜잭션까지 간단한 DB 엔진의 핵심 구성 요소를 C++로 구현합니다. 풀 스캔 병목, 부분 커밋, WAL fsync 누락 같은 실전 문제 시나리오를 함께 다룹니다.
• C++로 O(1) LRU 캐시 만들기: unordered_map + list, splice, 흔한 반복자 실수unordered_map에 list 반복자를 저장하고 splice로 노드를 앞으로 옮겨 get과 put을 모두 O(1)로 처리하는 LRU 캐시를 C++ 템플릿으로 구현합니다. 용량 초과 시 eviction 순서와 용량 0 같은 경계 조건도 다룹니다.
• C++에서 DB 연동하기: SQLite·PostgreSQL(libpq), 연결 풀, Prepared Statement, 트랜잭션C++ 데이터베이스 연동 정리. SQLite와 PostgreSQL(libpq) 기본, DB 래퍼 구현, 연결 풀, Prepared Statement와 SQL 인젝션 방지, 트랜잭션 관리, 풀 사용 여부에 따른 성능 차이를 다룹니다.
• C++에서 split·join·trim·replace 구현하기: getline·string_view·std::regex 비교C++ 문자열 알고리즘 정리. split(getline·stringstream·string_view), join(ostringstream), trim(find_first_not_of), replace와 std::regex_replace, 정규식을 한 번 컴파일해 재사용하는 법과 성능 팁을 다룹니다.
• const·noexcept·[[nodiscard]]로 C++ 인터페이스 의도 명확히 하기const 없이 넘긴 설정이 어딘가에서 바뀌거나 init() 실패를 무시하는 문제를 const correctness, noexcept, [[nodiscard]]로 막는 방법을 다룹니다. mutable의 쓰임, 이동 생성자에 noexcept가 없을 때 vector가 복사를 고르는 이유도 설명합니다.
• Docker DevContainer로 C++ 빌드 환경 통일하기C++ 빌드 환경을 Docker 이미지로 고정하는 방법입니다. 멀티 스테이지 빌드, vcpkg/Conan 의존성 캐시, VS Code Dev Container 설정, ccache·BuildKit 캐시, 컨테이너 안 GDB 디버깅과 자주 나는 런타임 에러를 다룹니다.
• noexcept로 C++ 이동 연산 최적화하기: 예외 계약 설계 패턴커스텀 타입을 넣은 vector의 resize가 느린 이유가 이동 생성자에 noexcept가 없어 복사를 고르기 때문이라는 데서 출발합니다. noexcept 지정자와 연산자, move_if_noexcept, 조건부 noexcept, 예외 안전성 보장 수준과 terminate 문제를 다룹니다.
• PGO·LTO로 C++ 컴파일러 최적화하기: -O2 vs -O3 차이와 측정법-O2와 -O3가 실제로 무엇을 다르게 하는지, LTO(Full·Thin)로 파일 경계를 넘는 인라인을 켜는 법, PGO의 계측→실행→재컴파일 3단계를 GCC·Clang·MSVC 옵션별로 설명하고 -march=native로 인한 SIGILL 같은 배포 함정도 다룹니다.
• printf 디버깅에서 벗어나기: GDB·LLDB 브레이크포인트, 워치포인트, 단계 실행 기초세그폴트 위치를 모르거나 루프의 특정 반복에서만 버그가 날 때처럼 printf로는 막히는 상황별로 GDB와 LLDB 사용법을 익힙니다. 조건부 브레이크포인트, 워치포인트로 메모리 오염 추적, next와 step의 차이, x 명령으로 메모리를 읽는 법을 예제로 다룹니다.
• Qt로 C++ 첫 GUI 만들기: CMake 프로젝트, 위젯과 레이아웃, 시그널과 슬롯C++로 창을 띄우고 버튼을 넣는 첫 단계를 Qt와 CMake로 밟아 봅니다. 레이아웃 배치, 람다와 멤버 함수로 시그널·슬롯 연결, Qt5와 Qt6 문법 차이를 예제로 설명하고 Could not find Qt6, vtable 링크 에러, 슬롯이 호출되지 않는 문제도 다룹니다.
• shared_ptr 심화: enable_shared_from_this와 aliasing 생성자 활용this를 shared_ptr로 감싸다 이중 해제로 크래시한 적 있나요? enable_shared_from_this, aliasing 생성자, shared_ptr 스레드 안전성, 멤버 포인터 수명 관리까지. 실전 문제 시나리오와 프로덕션 패턴.
• std::optional로 '값 없음' 표현하기: value_or, C++23 and_then·transform, 에러 처리 패턴조회 실패나 파싱 실패처럼 값이 없을 수 있는 결과를 널 포인터나 -1 대신 std::optional로 표현하는 방법을 DB 조회, 설정 파싱, 캐시 예제로 보여주고, value_or와 C++23 and_then, transform, or_else로 검사 코드를 줄이는 법을 설명합니다.
• string_view와 span: 복사 없이 넘기기, SSO와의 관계, mdspan, 댕글링 방지C++ std::string_view와 std::span 정리. 복사 없이 문자열과 배열을 넘기는 방법, SSO와의 관계, mdspan, 댕글링 참조가 생기는 경우와 방지법, 성능 비교를 다룹니다.
• time() 대신 std::chrono: duration·time_point, 클럭 선택, duration_cast, C++20 달력C++ time() 대신 std::chrono로 정확한 시간 측정. duration, time_point, system_clock, steady_clock, duration_cast, 벤치마크·타임아웃·로그 타임스탬프까지 실전 패턴.
• unique_ptr 고급 활용: 커스텀 삭제자, 배열, Pimpl, C API 핸들 감싸기C++ unique_ptr 고급 활용. 커스텀 삭제자와 EBO로 오버헤드 없애기, unique_ptr<T[]> 배열, Pimpl 패턴과 ABI 안정성, 팩토리와 이동 의미론, malloc/free·FILE*·HANDLE 같은 C API 연동을 다룹니다.
• Valgrind Memcheck로 C++ 메모리 누수 찾아내기C++ Valgrind Memcheck로 메모리 누수·힙 버퍼 오버런·초기화 안 된 값을 찾는 방법. definitely lost·invalid read/write·uninitialised value 출력 해석, suppression 파일 작성, CI 통합까지 예제로 설명합니다.
• Windows에서만 파일을 못 찾을 때: std::filesystem 경로 연산, 디렉터리 순회, 권한Linux·macOS에선 되는데 Windows에서만 파일을 못 찾는 문제에서 출발해 std::filesystem을 정리합니다. 경로 연산, 디렉터리 순회, 파일 복사·이동·삭제, 권한, 자주 나는 에러를 다룹니다.
• X-Macro로 중복 없애기: enum↔문자열 매핑, 에러 코드 표, 상태 머신, 커맨드 테이블enum과 문자열 배열을 따로 정의하다 한쪽만 고쳐 어긋나는 문제를 X-Macro로 한 곳에서 관리하는 방법을 보여줍니다. enum↔문자열 양방향 변환과 개수 자동 계산, 에러 코드·HTTP 상태 표, 상태 머신 전이 테이블, CLI 커맨드 디스패치 예제를 다룹니다.

고급 (105편)

• 나만의 Iterator 만들기: Forward부터 Bidirectional까지직접 만든 컨테이너에 std::sort를 쓰고 싶을 때 필요한 요구 사항과 iterator_traits를 짚고, Input부터 Random Access까지 반복자를 단계별로 구현합니다. 카테고리 과대 선언, 후위 ++ 반환 타입 실수와 C++20 iterator_concept도 다룹니다.
• 래퍼 함수에서 인자가 복사될 때: 유니버설 참조와 std::forward로 완벽한 전달 구현하기C++ 완벽한 전달(Perfect Forwarding) 정리. 래퍼 함수에서 인자가 복사되는 문제, 유니버설 참조, std::forward, 참조 축약 규칙, emplace 계열 함수와 성능 비교를 다룹니다.
• 루프가 병목일 때: 자동 벡터화, std::execution 병렬 정책, SSE·AVX2·AVX-512 인트린직C++ SIMD와 병렬 알고리즘 정리. 루프 병목에서 출발해 std::execution 정책, 자동 벡터화 조건, SSE·AVX2·AVX-512 인트린직 사용법, 자주 나는 에러와 성능 벤치마크를 다룹니다.
• 빈 클래스가 1바이트를 먹는 이유: EBCO와 C++20 [[no_unique_address]]빈 클래스가 1바이트를 차지하는 이유와, 커스텀 삭제자를 넣은 unique_ptr이나 빈 할당자를 가진 컨테이너가 커지는 문제를 EBCO와 C++20 [[no_unique_address]]로 해결하는 방법, 압축 쌍 직접 구현을 설명합니다.
• 임베디드 C++ 최적화: 플래시 크기, RAM 정적 할당, 전력 소모, 실시간성(WCET)64KB 플래시에 펌웨어가 안 들어가고, 스택이 넘치고, 배터리가 하루를 못 가는 상황을 다룹니다. LTO와 printf 제거로 플래시 줄이기, 정적 할당과 풀 allocator, 슬립 모드와 DMA, ISR 최소화와 WCET 예측을 C++ 관점에서 설명합니다.
• C++ 값 카테고리: lvalue, prvalue, xvalue를 구분하는 기준C++ 표현식이 lvalue, prvalue, xvalue 중 무엇인지 구분하는 기준과, 그 결과가 어떤 참조에 바인딩될 수 있는지를 예제로 정리합니다. std::move가 실제로는 xvalue로 캐스팅할 뿐이라는 점, decltype 결과가 달라지는 규칙, 불필요한 move 실수도 다룹니다.
• C++ 객체 풀 구현: RAII 반납 래퍼, 동적 확장, reset 누락과 스레드 안전게임 오브젝트처럼 자주 생성되고 사라지는 객체를 미리 만들어 두고 재사용하는 Object Pool을 구현합니다. 반납을 자동화하는 RAII 래퍼, 부족할 때 늘리는 동적 확장, 타입별 풀 관리자를 만들고 reset 누락과 스레드 안전 문제를 짚습니다.
• C++ 검색 엔진 구현 | 역색인·TF-IDF 랭킹·자동완성문서를 전부 순회하는 grep식 검색이 왜 느린지에서 출발해, C++로 posting 리스트 기반 역색인과 TF-IDF 점수 계산, Trie 자동완성을 차례로 구현합니다. 한글 토큰화 문제, Trie 메모리 폭증, 인덱스 샤딩과 갱신 전략도 다룹니다.
• C++ 게임 엔진 기초 | 렌더링·물리·입력·스크립팅 시스템 구현 [#50-3]ECS 아키텍처를 기반으로 2D 게임 엔진의 렌더링·물리·입력·Lua 스크립팅 시스템을 구현합니다. 충돌 감지 누락, 물리 터널링, Lua 콜백 nil 에러 같은 실전 트러블슈팅과 Box2D 연동까지 다룹니다.
• C++ 고급 멀티스레딩 | 스레드 풀·Work StealingC++ 스레드 풀, Work Stealing, Lock-Free 큐, 메모리 순서, Thread-Local Storage를 직접 구현하며 각 패턴이 해결하는 문제와 흔한 버그(작업 유실, ABA, lost wakeup, TLS 잔여 상태)를 설명합니다.
• C++ 기술 부채 관리: 레거시 C++ 프로젝트를 현대화하는 전략적 리팩토링손대기 무서운 레거시 C++ 코드를 전면 재작성하지 않고 위험도·변경 빈도·의존성으로 우선순위를 매겨 조금씩 현대화하는 전략을 다룹니다. raw 포인터를 unique_ptr로, 매크로를 constexpr로 바꾸는 예제와 deprecated 경로로 API 호환을 지키는 법을 설명합니다.
• C++ 기존 프로젝트를 Module로 전환 | 단계별 마이그레이션 [#24-2]헤더 기반 프로젝트를 한 번에 갈아엎지 않고 의존성이 적은 유틸부터 모듈로 옮기는 전환 절차를 보여줍니다. include와 import 공존, export 범위 결정, 인터페이스·구현 유닛 분리, MSVC .ixx를 포함한 CMake 설정과 증분 빌드 효과를 다룹니다.
• C++ 다이아몬드 상속 문제: virtual 상속의 동작과 초기화 순서, 컴포지션 대안C++ 다중 상속에서 같은 기본 클래스가 두 번 포함되는 다이아몬드 문제를 예제로 재현하고, virtual 상속이 객체 레이아웃을 바꿔 이를 해결하는 방식, 최하위 클래스가 가상 기본 클래스를 초기화하는 순서, 컴포지션 대안을 설명합니다.
• C++ 대용량 이미지 처리: OpenCV Mat 참조 카운팅, 필터·변환, SIMD, 멀티스레드 파이프라인썸네일을 만들다 메모리가 터지거나 회전 후 이미지가 잘리는 문제를 OpenCV로 해결하는 방법을 다룹니다. cv::Mat 참조 카운팅과 스트리밍 로드, 블러·샤프닝·Canny 필터, 리사이즈와 회전, 색공간과 EXIF 방향 처리, SIMD·멀티스레드 파이프라인을 설명합니다.
• C++ 디버깅 실전: GDB·LLDB watchpoint와 코어 덤프, ASan·TSan·UBSan, 메모리 누수·데드락, 프로덕션 크래시 추적C++ 버그를 재현하고 좁혀 가는 방법. GDB/LLDB 고급 기법(watchpoint, 조건부 브레이크포인트, 코어 덤프, 멀티스레드), ASan·TSan·UBSan·MSan과 Valgrind, 메모리 누수·데드락·반복자 무효화 추적, 구조화 로깅과 크래시 리포터까지 실전 시나리오로 정리합니다.
• C++ 람다 참조 캡처 심화 — 수명 의미론, 캡처 규칙, ASAN, 실무 안전 패턴참조 캡처([&]) 수명·댕글링, 캡처 목록 해석·이름 조회, IIFE와 참조, ASAN 검출 패턴, 프로덕션 안전 설계를 컴파일러 모델 관점에서 정리합니다. 값 캡처([x])는 클로저 객체 안에 복사본을 두므로, 외부 스코프가 끝난 뒤에도 그 복사본은 클로저 수명에 묶입니다.
• C++ 리눅스 시스템 프로그래밍 | 시스템 콜 호출과 커널 인터페이스 이해fd 고갈, read()의 0 반환 무시, EINTR, 부분 write처럼 시스템 콜을 대충 다룰 때 생기는 문제를 예제로 짚습니다. glibc 래퍼와 syscall(2) 직접 호출의 차이, poll·epoll 멀티플렉싱, fd와 mmap을 RAII로 감싸는 방법, fork 후 fd 상속도 다룹니다.
• C++ 멀티 컴파일러 전략과 CI/CD 파이프라인 구축 | 실무 가이드내 PC에서는 되는데 다른 환경에서 깨지는 빌드를 막기 위해 GCC, Clang, MSVC를 함께 쓰는 전략을 다룹니다. 경고를 에러로 올리는 옵션, 컴파일러 감지 매크로와 플랫폼 차이 처리, GitHub Actions 빌드 매트릭스와 CMake Presets 구성까지 예제로 보여줍니다.
• C++ 멀티스레드 성능 튜닝 | 락 프리·작업 훔치기·스레드 풀 [#51-3]스레드를 늘렸는데 오히려 느려지는 원인을 락 경합과 false sharing에서 찾고, 캐시 라인 정렬, ABA 문제를 고려한 lock-free 스택, SPSC 큐, 작업 배치와 work stealing 스레드 풀로 개선하는 과정을 C++ 코드로 다룹니다.
• C++ 멀티스레딩 기초: std::thread·mutex·생산자-소비자와 자주 겪는 문제std::thread 생성과 인자 전달, mutex와 lock_guard로 경쟁 조건 막기, 생산자-소비자와 스레드 풀 구현, 그리고 데드락, detach 후 댕글링 참조, false sharing처럼 멀티스레드 코드에서 자주 겪는 문제의 원인과 해결을 예제로 다룹니다.
• C++ 멀티채널 알림 서비스: 이메일·SMS·FCM 푸시·WebSocket·Webhook 통합과 재시도·DLQWebSocket 실시간 알림, FCM 푸시, SMTP 이메일, SMS, Webhook을 하나의 알림 서비스로 통합하는 방법을 정리합니다. 채널별 재시도·백오프·DLQ, FCM 토큰 만료 처리, 이메일 rate limiting 같은 실전 트러블슈팅을 다룹니다.
• C++ 메모리 순서 예제로 이해하기: relaxed, acquire/release, seq_cst, consumeC++ std::atomic의 메모리 순서 정리. memory_order_relaxed, acquire/release, seq_cst, consume을 예제로 비교하고, 동기화 패턴과 자주 나는 실수, x86과 ARM에서의 비용 차이를 다룹니다.
• C++ 메타프로그래밍의 진화: Template에서 Constexpr, 그리고 Reflection까지템플릿 기반 메타프로그래밍에서 constexpr·if constexpr·fold expression·Concepts, 그리고 C++26 Reflection까지 C++ 메타프로그래밍의 흐름을 예제와 흔한 컴파일 에러 중심으로 정리합니다.
• C++ 배열: 메모리 레이아웃, std::array, 캐시 최적화C 배열이 함수 인자로 넘어갈 때 포인터로 쇠퇴하는 규칙과 2차원 배열의 함정, std::array 설계와 C 배열·vector의 선택 기준, 행 우선 레이아웃에 맞춘 캐시 친화 순회, C++23 std::mdspan까지 다룹니다.
• C++ 백엔드·게임 서버 시스템 디자인 | 대규모 동시 접속과 메모리 풀피크 타임에 서버가 멈추거나 메모리가 며칠째 늘어나는 게임·백엔드 서버 문제를 이벤트 루프, 스레드 풀, Strand 기반 연결 직렬화로 푸는 설계를 다룹니다. 메모리·오브젝트 풀, 세션과 패킷 버퍼 구조, Acceptor-Worker 분리 코드 골격도 설명합니다.
• C++ 보안 코딩 가이드: 오버플로우 방지와 암호화 라이브러리(OpenSSL) 실전 연동정수·버퍼 오버플로우를 막는 코드 작성법과 OpenSSL 3.x를 RAII로 감싸 쓰는 방법을 다룹니다. 암호학적 난수, HMAC-SHA256, AES-256-GCM, PBKDF2 예제와 함께 ECB 모드, IV 재사용, 타이밍 공격, SSL_VERIFY_NONE 같은 흔한 취약점을 설명합니다.
• C++ 분기 예측: likely·unlikely 속성과 분기 없는 코드로 성능 개선하기CPU 파이프라인에서 분기 예측이 실패할 때 생기는 비용을 설명하고, C++20 [[likely]]·[[unlikely]] 힌트, 조건문을 산술 연산으로 바꾸는 branchless 코드, 데이터 정렬 효과, 룩업 테이블과 PGO 적용 방법을 다룹니다.
• C++ 비동기 작업과 Coroutine | co_await로 콜백 지옥 탈출하기 [#23-3]C++20 코루틴으로 비동기 작업을 co_await하는 방법을 다룹니다. Awaitable 프로토콜, 대칭 전송을 쓰는 Task 타입 구현, Boost.Asio awaitable 연동, 에러 처리, 수명 관리, 타임아웃·병렬 요청·취소 패턴을 설명합니다.
• C++ 서버 배포: Docker 멀티스테이지, systemd, Kubernetes 무중단 배포, Prometheus 모니터링C++ 서비스를 프로덕션에 배포하는 방법. Docker 멀티스테이지 빌드, systemd 서비스, Kubernetes Deployment·Ingress·readinessProbe, 롤링 업데이트, CI/CD, Prometheus·Grafana·spdlog, glibc·OOM·502 에러 대응을 다룹니다.
• C++ 성능 최적화 순서: 복사 제거, 할당 줄이기, 캐시 지역성, 컴파일러 옵션값 전달을 참조와 move로 바꾸고, reserve와 객체 풀로 할당을 줄이고, 데이터 지역성을 살려 캐시 미스를 줄이는 순서로 C++ 코드를 빠르게 만드는 방법을 설명합니다. 컴파일 옵션, 룩업 테이블, SIMD 예제와 gprof, Callgrind, perf 사용법도 담았습니다.
• C++ 실시간 모니터링 대시보드: Grafana·Prometheus 통합새벽에 API가 멈췄는데 로그로는 원인을 못 찾을 때를 가정해, C++ 서버에 Counter·Gauge·Histogram 레지스트리를 직접 만들어 /metrics로 노출하고 Prometheus·Grafana 패널과 알람 규칙을 붙입니다. 카디널리티 폭증과 버킷 설정 실수도 다룹니다.
• C++ 예외 비용: Zero-Cost 모델의 의미, throw 비용, noexcept와 이동 생성자C++ 예외의 Zero-Cost 모델이 실제로 무엇을 의미하는지, 정상 경로와 예외 경로의 비용 차이, noexcept가 이동 생성자 성능에 미치는 영향, 그리고 예외를 제어 흐름으로 남용했을 때의 실제 성능 손실을 벤치마크와 함께 정리합니다.
• C++ 인라인 어셈블리: GCC 확장 asm 제약 문자·clobber, MSVC 차이, 인트린식이 나은 경우GCC/Clang 확장 asm의 출력·입력 피연산자, 제약 문자, clobber 목록을 읽고 쓰는 법과 MSVC 문법의 차이, memory clobber로 컴파일러 배리어를 만드는 원리를 CPUID·타임스탬프 카운터 예제로 설명하고, 인트린식이 더 나은 경우를 구분합니다.
• C++ 인터페이스 설계와 PIMPL: 컴파일 의존성을 끊고 바이너리 호환성(ABI) 유지하기private 멤버 하나만 바꿨는데 전체가 다시 빌드되는 문제를 PIMPL로 막는 방법을 설명합니다. 헤더 의존성이 재컴파일 범위를 넓히는 원리, Rule of Five 처리, incomplete type 에러, 이동 후 상태, PIMPL의 비용과 대안(전방 선언, Fast PIMPL)을 다룹니다.
• C++ 정책 기반 설계: 템플릿 매개변수로 동작을 컴파일 타임에 조합하기C++ Policy-Based Design으로 템플릿 매개변수를 통해 컴파일 타임에 동작을 조합하는 방법을 정리합니다. 스마트 포인터, 로거, 컨테이너 성장 전략 예제와 인터페이스 불일치·복잡도 함정을 다룹니다.
• C++ 제약된 환경에서의 C++: Exception과 RTTI 없이 안전한 코드 짜기플래시가 작은 MCU나 실시간 루프처럼 예외와 RTTI를 꺼야 하는 환경에서 오류를 반환값·optional·expected로 전달하는 방법을 다룹니다. 팩토리와 두 단계 초기화, dynamic_cast 대신 variant·enum 태그 분기, 할당 없는 고정 버퍼 예제도 보여줍니다.
• C++ 직렬화 방식 비교: nlohmann·simdjson·Glaze JSON, 바이너리, Protobuf, C++26 리플렉션C++ 직렬화: nlohmann/simdjson/Glaze JSON, 직접 설계한 바이너리 포맷, Protobuf, cereal, MessagePack, C++26 리플렉션(P2996). 포맷 선택·버전 호환성·자동 직렬화.
• C++ 채팅 서버 아키텍처: Acceptor-Worker 구조, 방 관리, 메시지 라우팅, 커넥션 풀동시 접속 폭주, 메시지 전송 중 데이터 레이스, 느린 클라이언트 한 명이 전체를 늦추는 문제를 채팅 서버 설계로 풀어 봅니다. Acceptor-Worker 구조와 io_context 풀, RoomManager 기반 방 관리, 메시지 라우터, 연결 수 제한을 구현합니다.
• C++ 초경량 HTTP 웹 프레임워크 바닥부터 만들기Express나 FastAPI 같은 사용감을 C++로 최소 구현하면서 요청 파싱, 경로 파라미터를 지원하는 라우터, 로깅·공통 헤더·인증 미들웨어 체인, 응답 직렬화를 차례로 만듭니다. Hello World 서버에서 라우팅과 미들웨어를 합친 예제까지 빌드해 봅니다.
• C++ 커스텀 Allocator: 메모리 풀·스택·추적 할당자와 PMRC++ STL Allocator 인터페이스로 메모리 할당을 커스터마이징하는 방법을 메모리 풀, 스택, 추적 할당자 예제와 PMR(polymorphic_allocator)로 정리합니다. 할당자 비교, 전파 정책, 정렬 함정까지 다룹니다.
• C++ 커스텀 Concepts 작성 | 도메인에 맞는 제약 조건 정의하기 [#22-2]표준 concept만으로는 원하는 타입만 받기 어려울 때 Serializable, Hashable 같은 도메인 concept를 직접 정의하는 방법을 다룹니다. requires 표현식의 반환 타입·noexcept 검사, &&와 || 조합, ADL과 swap 문제, 순환 정의 같은 흔한 오류도 설명합니다.
• C++ 커스텀 Range 작성 | range 개념을 만족하는 타입 만들기 [#25-3]직접 만든 컨테이너나 래퍼를 범위 기반 for와 std::ranges 알고리즘에 그대로 넣으려면 무엇이 필요한지 정리합니다. 반복자 요구 사항, random_access 반복자, sentinel, 직접 만드는 filter 어댑터, 수명 문제를 C++20 기준 예제로 다룹니다.
• C++ 컴파일 타임 리플렉션 | C++26 Reflection·magic_enum·매크로 직렬화·검증구조체가 늘 때마다 to_json·from_json을 손으로 쓰는 반복을 줄이려고 C++26 Reflection(P2996)의 개념과 예제를 살펴보고, 지금 쓸 수 있는 magic_enum, Boost.PFR, X-Macro 기반 멤버 순회를 비교합니다. magic_enum의 제약과 흔한 에러도 다룹니다.
• C++ 컴파일 타임 최적화 | constexpr·PCH·모듈·ccache·Unity 빌드 [#15-3]매번 같은 룩업 테이블을 런타임에 계산하던 코드를 constexpr 함수, if constexpr, consteval로 컴파일 타임에 옮기는 방법을 다룹니다. 빌드 시간을 줄이는 쪽으로는 병목 측정, PCH, C++20 모듈, ccache, distcc 분산 컴파일, Unity 빌드를 CMake 설정과 함께 설명합니다.
• C++ 컴파일 타임 프로그래밍 기법 | 런타임 오버헤드 제거와 constexpr·consteval 실전런타임 오버헤드를 줄이기 위한 컴파일 타임 프로그래밍. constexpr 함수, if constexpr, consteval(C++20), 템플릿 메타 vs constexpr 비교, 성능 벤치마크, 프로덕션 패턴까지.
• C++ 타입 소거(Type Erasure): std::function 내부 원리와 Concept·Model 직접 구현상속 관계가 없는 여러 타입을 하나의 인터페이스로 다루는 타입 소거 패턴을 std::function과 std::any의 내부 원리, 직접 만든 Concept·Model 구현으로 설명합니다. 콜백·플러그인·메시지 큐 예제와 가상 함수 방식과의 비용 차이도 다룹니다.
• C++ 타입 추론 규칙: auto의 참조·const 처리, decltype, 템플릿 추론, decltype(auto)C++ 타입 추론 정리. auto 키워드와 함정, decltype 연산자, 템플릿 타입 추론 규칙, 반환 타입 추론, 구조화 바인딩(C++17), decltype(auto), 완벽한 전달을 예제로 다룹니다.
• C++ 태그 디스패칭: iterator_category로 오버로드 고르기와 if constexpr·Concepts 비교값이 아니라 빈 구조체 타입으로 오버로드를 고르는 태그 디스패칭을 std::distance의 iterator_category 분기 예제로 설명합니다. 타입별 직렬화와 복사 최적화 예제, if constexpr·SFINAE·Concepts와 비교했을 때 언제 이 패턴이 여전히 읽기 쉬운지도 다룹니다.
• C++ 템플릿 메타프로그래밍 심화 — SFINAE·타입 특성·태그 디스패치템플릿 메타프로그래밍(TMP)에서 컴파일러가 오버로드 후보를 거르는 SFINAE 규칙, type_traits의 구현 원리, 태그 디스패치와 if constexpr의 선택 기준, 컴파일 타임 계산을 어디에 둘지를 라이브러리 설계 관점에서 정리합니다.
• C++ 템플릿 인자 추론 규칙: 값·참조·전달 참조, decay, CTAD함수 템플릿에 값으로 넘기면 const와 참조가 사라지고 배열은 포인터로 decay되는 등, 컴파일러가 인자에서 T를 추론하는 규칙을 예제로 정리합니다. 타입 불일치로 추론이 실패할 때 고치는 법, 완벽한 전달, C++17 CTAD도 다룹니다.
• C++ 템플릿 템플릿 인자 | template template parameter 가이드vector<int>처럼 구체화된 타입이 아니라 vector 자체를 템플릿 인자로 받는 template template parameter 문법을 설명합니다. 표준 컨테이너의 Allocator 인자 때문에 매칭이 실패하는 문제, C++17 typename 선언, 컨테이너 정책 주입 예제를 다룹니다.
• C++ 함수형 프로그래밍 심화 — 고차 함수·모나드·RangesC++에서 고차 함수·클로저, 커링, Ranges 지연 평가, optional/expected 모나드 체이닝, 프로덕션 FP 관용구를 객체 모델과 함께 정리합니다. 함수형 프로그래밍(FP)은 값과 함수의 조합으로 프로그램을 구성하고, 부작용을 경계에 모으는 사고방식입니다.
• C++ ADL(인자 종속 조회): swap 관용구가 동작하는 이유와 엉뚱한 함수가 호출될 때네임스페이스 한정 없이 호출한 함수가 인자 타입의 네임스페이스에서 검색되는 ADL 규칙을 std::cout, 연산자 오버로딩, swap 관용구, 직렬화 예제로 설명하고, 의도치 않은 함수가 선택되는 문제와 막는 방법을 다룹니다.
• C++ CMake 고급 | 멀티 타겟·외부 라이브러리 관리 (대규모 프로젝트 빌드)라이브러리를 추가할 때마다 빌드가 깨지는 대규모 프로젝트를 타겟 단위 CMake로 정리하는 방법을 다룹니다. PUBLIC·PRIVATE·INTERFACE 전파, Generator Expression, find_package와 FetchContent 선택, undefined reference 해결도 설명합니다.
• C++ const·constexpr 내부 동작 | 평가 시점·if constexprconst와 constexpr의 평가 시점 차이, constexpr 함수 제약, if constexpr 분기 제거, consteval 즉시 함수, 프로덕션 const 정확성까지 컴파일러 관점에서 정리합니다.
• C++ CRTP: 가상 함수 없이 정적 다형성 구현하기와 C++23 deducing thisC++ CRTP(Curiously Recurring Template Pattern)로 가상 함수 없이 정적 다형성을 구현하는 방법을 카운터 믹스인, 비교 연산자 자동 생성, 싱글톤, 체이닝 인터페이스 예제로 정리합니다. 가상 함수와의 성능 비교와 캐스팅·순환 의존 함정까지 다룹니다.
• C++ Expression Templates: 벡터 연산의 임시 객체를 없애는 지연 평가 구현a + b + c 같은 벡터 연산이 매 단계 임시 객체를 만드는 문제를 Expression Templates로 풀어, 연산을 식 트리로 쌓아 두었다가 대입 시점에 한 번의 루프로 평가하는 방법을 구현합니다. auto로 받았을 때의 댕글링과 앨리어싱 함정도 짚습니다.
• C++ Facade 패턴: 복잡한 서브시스템 앞에 단순한 진입점 두기와 Pimpl·CRTP 변형C++ Facade 패턴으로 복잡한 서브시스템을 단순한 인터페이스로 감싸는 방법. 멀티미디어·데이터베이스 예제, Pimpl 컴파일 방화벽, 가상 디스패치 비용, 템플릿·CRTP 기반 정적 파사드를 정리합니다.
• C++ Fuzz Testing: 예상치 못한 입력값으로 프로그램의 견고함 테스트하기개발자가 떠올리지 못한 입력으로 파서를 깨뜨리는 퍼즈 테스트를 libFuzzer 중심으로 시작합니다. 퍼즈 타겟 작성과 sanitizer 빌드 옵션, URL·패킷 파서 퍼징, FuzzedDataProvider 사용, 느린 퍼징·OOM 대처, CI 연동과 코퍼스 관리까지 다룹니다.
• C++ Generator로 지연 시퀀스 만들기: co_yield, 무한 수열, filter·map·take 파이프라인C++20 코루틴으로 Generator를 구현하는 방법. co_yield와 promise_type, 지연 평가와 무한 시퀀스, filter·map·take 조합, 수명(dangling) 오류, vector 대비 성능, 파일 스트리밍 예제를 다룹니다.
• C++ GUI | Qt 프레임워크: 위젯부터 MOC·시그널/슬롯·이벤트 루프·Graphics View까지Qt Widgets 기초 예제(버튼, 레이아웃, 메뉴, 텍스트 에디터)와 함께 MOC가 하는 일, 시그널/슬롯 연결 타입, 이벤트 루프, Graphics View, 부모-자식 소유권과 스레드 친화성을 정리하고, vtable 링크 에러나 Cannot queue arguments 같은 실제 오류의 원인을 설명합니다.
• C++ I/O 성능 최적화 | io_uring·mmap·DMA·제로카피 [#51-6]read/write 루프가 병목일 때 io_uring 배치 제출, mmap 파일 매핑, sendfile·splice·copy_file_range 제로카피가 각각 어떤 비용(시스템 콜, 복사)을 줄이는지 Linux C++ 코드로 정리하고, SIGBUS·SQ 고갈·짧은 읽기 같은 함정을 다룹니다.
• C++ inline namespace로 API 버전 관리하기: 기본 버전 전환과 ABI 불일치 검출inline namespace로 v1, v2 같은 API 버전을 나누면서 기본 버전을 바꿔도 사용자 코드는 그대로 두는 방법, 네임스페이스 이름이 링커 심볼에 들어가 ABI 불일치를 링크 단계에서 드러내는 원리, ADL과 특수화에서 주의할 점을 다룹니다.
• C++ Lock-Free 자료구조: CAS로 스택·큐 만들기, 메모리 순서, ABA 문제와 Hazard PointerC++ Lock-Free 프로그래밍 정리. 원자 연산과 CAS, Lock-Free 스택과 큐 구현, memory_order 선택, ABA 문제와 Hazard Pointer 해법, 자주 나는 에러와 락 기반 대비 성능을 다룹니다.
• C++ Mixin 패턴: 템플릿 상속으로 로깅·카운팅 기능 조합하기템플릿 매개변수로 받은 기반 클래스를 상속해 로깅·카운팅 같은 기능 조각을 필요한 클래스에만 조합하는 C++ Mixin 패턴을 다룹니다. 다중 Mixin, CRTP Mixin, 조건부 기능 선택, 메서드 체이닝을 예제로 보여 줍니다.
• C++ PIMPL과 브릿지 패턴 | 구현 숨기기와 추상화 [#19-3]private 멤버 하나를 추가했을 뿐인데 이 클래스를 include하는 모든 .cpp가 다시 컴파일됩니다. PIMPL로 컴파일 의존성을 끊는 방법, unique_ptr와 불완전 타입 함정, 브릿지 패턴으로 추상과 구현을 분리하는 방법을 정리합니다.
• C++ Ranges Views와 파이프라인 | 지연 연산으로 효율적으로 다루기 [#25-2]중간 벡터를 여러 개 만드는 루프 코드를 C++20 Ranges view 파이프라인(filter·transform·take·split·join)으로 바꾸고, 지연 평가가 동작하는 방식과 dangling view·조건부 파이프라인 타입 같은 함정을 정리합니다.
• C++ Rate Limiter 구현: 토큰 버킷 vs 슬라이딩 윈도우 vs 고정 윈도우, Redis 분산 제한C++로 API Rate Limiter를 구현하는 방법. 토큰 버킷(버스트 허용), 슬라이딩 윈도우(정확성), 고정 윈도우 알고리즘 비교, 스레드 안전한 키별 제한과 메모리 정리, Redis Lua 스크립트를 이용한 분산 제한을 다룹니다.
• C++ SFINAE vs Concepts | 언제 마이그레이션해야 할까enable_if로 쓴 SFINAE 코드를 C++20 Concepts와 requires 표현식으로 옮기면 무엇이 좋아지고 무엇이 어려워지는지 같은 예제로 비교합니다. 에러 메시지 품질, 레거시 코드 호환성, 과도한 제약과 순환 의존 같은 마이그레이션 함정을 다룹니다.
• C++ Small String Optimization (SSO) | string 성능 최적화 원리std::string이 짧은 문자열은 힙 할당 없이 객체 내부 버퍼에 저장하는 Small String Optimization의 구조를 설명하고, 주소 비교와 sizeof로 SSO 여부를 확인하는 법, 생성과 복사 벤치마크, 간단한 SSO 구현 예시를 다룹니다.
• C++ static 함수 정리: 클래스 static 멤버, 파일 스코프 static, 내부 링키지와 ODR함수에 붙는 static은 클래스 static 멤버 함수와 파일 스코프 static 함수라는 전혀 다른 두 뜻을 가집니다. this가 없는 멤버 함수, 내부 링키지와 익명 네임스페이스 비교, 헤더의 static 정의가 ODR과 코드 크기에 주는 영향을 예제로 봅니다.
• C++ STL 컨테이너: 연산별 성능 비교와 상황별 선택 기준vector, map, unordered_map, deque, list의 내부 구조와 반복자 무효화 규칙, 메모리 할당 전략, 캐시 성능 차이를 측정 방법과 함께 비교하고 상황별 컨테이너 선택 기준을 정리합니다.
• C++ type traits 활용: 표준 traits, std::enable_if, 커스텀 traits 작성정수만 받아야 할 템플릿에 vector를 넘겨 긴 에러가 나는 상황에서 출발해 is_integral·decay 같은 표준 traits, enable_if를 두는 위치별 차이, void_t로 멤버 존재를 검사하는 커스텀 traits를 다룹니다. if constexpr로 대체할 시점도 설명합니다.
• C++ Visitor 패턴: 더블 디스패치와 std::variant + std::visit 비교C++ Visitor 패턴을 더블 디스패치와 std::variant + std::visit 두 가지 방식으로 비교합니다. AST 순회, 상태 머신, overloaded 람다 헬퍼 등 실전 예제와 함정을 다룹니다.
• C++ vtable과 vptr: 가상 함수 호출이 동작하는 방식과 메모리·호출 비용C++ 가상 함수를 사용하면 객체 안에 vptr이 생기고, 이 포인터가 vtable을 가리켜 런타임에 올바른 함수를 찾습니다. 다형성이 어떻게 동작하는지, 메모리 구조와 성능까지 실전 예제로 정리합니다.
• C++14 초기화 캡처: move 캡처와 unique_ptr을 람다에 넘기는 패턴C++14부터 람다의 캡처 목록에 이름 = 표현식 형태를 쓸 수 있습니다. 이를 초기화 캡처(init-capture)라고 부릅니다. 클로저 객체 안에 지정한 이름의 멤버를 만들고, 오른쪽 표현식의 결과로 초기화합니다.
• C++17 스레드 풀 만들기: 작업 큐, future 반환, 우선순위·취소, 요청마다 스레드를 만들 때의 문제요청마다 std::thread를 만들다 스레드가 1000개로 불어난 상황에서 출발해 C++17 스레드 풀을 작업 큐, future 반환 submit, 우선순위, graceful shutdown 순서로 구현합니다. 참조 캡처 use-after-free, 중첩 submit 데드락, 백프레셔 부재도 다룹니다.
• C++17 실행 정책 seq·par·par_unseq: 병렬 알고리즘과 데이터 레이스 함정C++17 실행 정책으로 병렬 알고리즘을 구현하는 방법. seq, par, par_unseq 정책 비교, std::transform, std::sort 병렬화 실전 예제와 데이터 레이스·오버헤드 함정을 정리합니다.
• C++17 constexpr 람다: 암시적 constexpr 조건과 컴파일 타임 룩업 테이블C++17부터 람다가 조건을 만족하면 암시적으로 constexpr이 되는 규칙을 설명하고, 팩토리얼·거듭제곱·배열 초기화 같은 컴파일 타임 계산, 타입 검사와 조건부 컴파일, 룩업 테이블을 만드는 활용 패턴을 다룹니다.
• C++17 if constexpr: 컴파일 타임 분기로 템플릿 단순화하기와 static_assert(false) 문제if constexpr는 선택되지 않은 분기를 인스턴스화하지 않아 타입별 처리를 템플릿 하나로 쓸 수 있게 해 줍니다. 재귀 종료와 SFINAE 대체 예제, else에 static_assert(false)를 넣으면 생기는 문제, 분기마다 반환 타입이 달라지는 함정을 짚습니다.
• C++17·20·23 주요 기능 정리: 구조화 바인딩부터 Concepts·Ranges·std::print까지C++17의 구조화 바인딩, if constexpr, optional, variant, filesystem부터 C++20의 Concepts, Ranges, 코루틴, 모듈, <=> 연산자, C++23의 std::print와 다차원 첨자까지 각 기능이 기존 코드의 어떤 불편을 줄이는지 예제로 비교합니다.
• C++20 달력과 시간대: year_month_day와 zoned_time 사용법C++20 chrono의 year_month_day로 날짜를 표현하고 weekday로 요일을 계산하며, zoned_time으로 시간대를 변환하는 방법을 다음 영업일 계산, 회의 시간 변환, 반복 일정 예제로 설명합니다.
• C++20 코루틴 기초: co_await·co_yield와 Generator 구현값을 하나씩 만들어 주는 제너레이터와 콜백 없이 쓰는 비동기 Task를 C++20 코루틴으로 직접 구현합니다. co_yield·co_await·co_return의 동작, promise_type 필수 메서드, coroutine_handle 수명 규칙과 dangling 참조 같은 실수를 짚습니다.
• C++20 템플릿 람다: auto 람다와 차이, Concepts로 타입 제한하기C++20 템플릿 람다의 명시적 템플릿 매개변수 문법과 Concepts를 이용한 타입 제약, 여러 매개변수·파라미터 팩·제네릭 팩토리 패턴 등 실전 활용법과 자주 발생하는 컴파일 에러 해결법을 코드로 정리합니다.
• C++20 Concepts: SFINAE를 대체하는 제약 문법과 Subsumption난해한 템플릿 에러 메시지를 C++20 Concepts로 바꾸는 방법을 enable_if 코드와 나란히 비교합니다. requires 절과 requires 표현식, 표준 concept 계층, subsumption으로 오버로드 우선순위가 정해지는 원리와 흔한 제약 에러도 다룹니다.
• C++20 constexpr 컨테이너와 알고리즘: constexpr vector·string·new/delete의 규칙과 한계C++20에서 constexpr로 쓸 수 있게 된 std::vector·std::string·표준 알고리즘과 constexpr new/delete를 예제로 설명합니다. 할당이 상수 평가 밖으로 나갈 수 없는 규칙, 결과를 std::array로 옮기는 방법, 자주 나는 컴파일 에러와 컴파일러별 지원 버전을 다룹니다.
• C++20 Modules: import·export 문법, 컴파일러 지원 현황, 빌드 시간include가 쌓여 컴파일이 느려지는 문제를 C++20 모듈로 푸는 기본기를 다룹니다. export module과 import 문법, 전역 모듈 fragment로 기존 헤더 쓰기, 파티션 구성, GCC·Clang·MSVC·CMake 빌드 설정과 module not found 에러 대처를 설명합니다.
• C++20 range adaptor: views::filter·transform 파이프라인의 지연 평가와 댕글링 함정views::filter와 views::transform을 | 로 이어 붙인 파이프라인이 결과를 즉시 만들지 않고 순회할 때 계산되는 원리를 설명하고, 원본보다 오래 사는 뷰의 댕글링, 조건자 중복 호출, 어댑터 순서에 따른 비용 차이 같은 함정을 예제로 짚습니다.
• C++20 Ranges: views 파이프라인, projection, 성능 특성begin/end를 반복해 넘기고 람다로 멤버를 비교하던 STL 코드를 std::ranges 알고리즘과 프로젝션으로 줄이는 방법을 보여줍니다. filter·transform·take로 view 파이프라인을 만들고 벡터로 구체화하는 법, range concept 요구 사항, view 수명 함정도 다룹니다.
• C++20 ranges의 개념 계층: range 요건, input·forward·random_access_range, CPO 설계begin()과 end()만 있으면 range가 되는 최소 요건부터 input_range, forward_range, random_access_range로 계층이 나뉜 이유, std::ranges::begin이 평범한 함수가 아닌 커스터마이제이션 포인트 객체로 설계된 까닭을 C++20 코드로 설명합니다.
• C++20 std::barrier와 std::latch: 스레드 동기화 지점 만들기C++20 std::latch로 여러 스레드의 준비 완료를 한 번 기다리고, std::barrier로 단계마다 반복 동기화하며 완료 콜백을 실행하는 방법을 병렬 초기화, 파이프라인, 게임 프레임 동기화 예제로 설명합니다.
• C++20 std::views: filter·transform·take 지연 평가와 ranges::to로 구체화하기C++20 std::views의 filter, transform, take, drop을 파이프로 연결하면 중간 컨테이너 없이 지연 평가되는 원리를 설명합니다. 뷰가 원본을 소유하지 않아 생기는 댕글링, 재평가와 캐싱 문제, ranges::to로 결과를 컨테이너로 만드는 방법을 다룹니다.
• C++23 std::expected: 예외 없이 에러 전달하기와 and_then 체이닝C++23 std::expected로 값과 에러를 하나의 반환 타입에 담아, 예외 없이도 실패 이유를 호출자에게 전달하는 방법을 파일 읽기와 파이프라인 예제로 보여줍니다. and_then 체이닝, expected<void, E>, 예외와의 선택 기준도 다룹니다.
• C++26 리플렉션 기초: ^^ 연산자, std::meta::info, template for로 멤버 순회하기C++26에 채택된 정적 리플렉션(P2996)의 실제 문법을 정리합니다. ^^ 연산자와 std::meta::info, identifier_of·nonstatic_data_members_of·access_context, [: :] 스플라이스, template for와 define_static_array, [[=...]] 어노테이션, 컴파일러 지원 현황과 C++20 대안까지 다룹니다.
• C++로 10GB 파일 올리기: S3 멀티파트 업로드, MinIO, 재시도·진행률, CDN과 서명 URLC++로 S3 멀티파트 업로드를 구현해 10GB 파일도 메모리 폭발 없이 병렬 처리하는 방법을 정리합니다. MinIO 로컬 스토리지, 재시도·백오프, 진행률 표시, CDN 캐시 무효화, 서명된 URL까지 다룹니다.
• C++로 로드 밸런서 구현하기: Round-Robin·Least Connections·Consistent Hashing, 헬스 체크특정 서버에 트래픽이 몰리거나 한 대가 죽으면 502가 나는 문제를 C++ 로드 밸런서로 풀어 봅니다. 라운드 로빈, 가중치, 최소 연결, Consistent Hashing 구현과 Asio TCP 프록시, 비동기 헬스 체크와 서킷 브레이커, 빈 백엔드 목록 같은 경계 조건을 다룹니다.
• C++로 Redis 클론 만들기: Asio 이벤트 루프, 프로토콜 파싱, GET/SET 저장소Boost.Asio로 Acceptor와 세션을 만들고 간단한 텍스트 프로토콜을 파싱해 GET·SET·DEL·KEYS를 처리하는 최소 Redis 클론을 구현합니다. telnet·nc로 테스트하는 법과 redis-cli를 쓰려면 필요한 RESP 파싱, bad_weak_ptr, 쓰기 버퍼 수명, 멀티스레드 map 접근 문제도 다룹니다.
• C++로 REST API 서버 만들기: 라우터·미들웨어 체인·JWT 인증·요청 검증Express.js처럼 쓰기 쉬운 REST API 서버를 C++로 만들면서 라우터, 로깅·CORS 미들웨어 체인, Request·Response 클래스, JWT 인증, 요청 검증과 에러 핸들러, Swagger 문서를 차례로 구현합니다. CORS preflight 실패와 토큰 만료 대처도 다룹니다.
• C++와 Rust: 두 언어의 상호 운용성과 Memory Safety 논쟁의 실체레거시 C++ 코드를 유지하면서 새 기능을 Rust로 쓰려면 C ABI를 경계로 삼아야 합니다. extern "C"와 #[no_mangle]로 양방향 호출하기, 구조체 레이아웃 맞추기, bindgen과 cxx 크레이트, FFI 경계의 소유권 꼬임과 panic 전파 문제를 다룹니다.
• constexpr 기초부터 C++26까지: constexpr 함수·생성자, const와의 차이, 확장된 규칙C++ constexpr 정리. constexpr 변수와 함수, 생성자, const와의 차이, C++14/20/23 확장, C++26에서 추가되는 기능(void* 캐스트, placement new, 예외, 리플렉션)과 자주 만나는 컴파일 에러를 다룹니다.
• enable_shared_from_this: this를 shared_ptr로 넘기는 법과 bad_weak_ptr 함정C++ enable_shared_from_this 정리. shared_from_this()로 this를 안전하게 공유하는 방법, 생성자에서 호출할 때 나는 bad_weak_ptr 예외, weak_from_this()(C++17), 비동기 콜백 활용을 다룹니다.
• Google Mock으로 C++ 의존성 분리하기: MOCK_METHOD·EXPECT_CALL·매처데이터베이스나 네트워크 없이 단위 테스트를 돌리려면 인터페이스를 분리하고 Google Mock으로 대역을 만들어야 합니다. MOCK_METHOD 정의, EXPECT_CALL의 호출 횟수·순서 검증, WillOnce와 매처, StrictMock·NiceMock 차이, 자주 나는 컴파일 에러를 다룹니다.
• SFINAE 패턴 정리: enable_if, void_t, Detection Idiom과 Concepts로 옮길 시점C++ SFINAE 정리. enable_if, void_t와 표현식 검사, Detection Idiom과 is_detected, 템플릿 오버로드 분기, 레거시 SFINAE 코드를 C++20 Concepts로 옮기는 기준을 다룹니다.
• static·extern·const·constexpr·inline·volatile·mutable: C++ 키워드가 실제로 바꾸는 것C++ 주요 키워드 정리. static, extern, const, constexpr, inline, volatile, mutable의 의미와 사용법, 링키지와 저장 기간, 메모리 레이아웃, 키워드 조합 패턴을 다룹니다.
• std::pmr로 메모리 할당 최적화하기 | Polymorphic Memory Resource 활용법C++17 std::pmr의 polymorphic_allocator, monotonic_buffer_resource, pool_resource를 언제 어떻게 쓰는지, 수명·복사 시 리소스 선택·정렬 함정과 커스텀 memory_resource 구현, 측정할 때 주의할 점까지 실전 예제로 정리합니다.

난이도 표시가 없는 글 (2편)

• 모던 C++ (C++11~C++20) 핵심 문법 치트시트 | auto·람다C++11부터 C++20까지 버전별로 자주 쓰는 문법을 모았습니다. auto와 람다, 스마트 포인터, 구조화된 바인딩과 optional·variant, if constexpr, Concepts·Ranges·코루틴·삼원 비교 연산자를 짧은 예제로 바로 찾아볼 수 있습니다.
• spdlog로 C++ 로깅하기: 다중 싱크, 로테이션, 비동기 로깅과 싱크 수명 함정C++ spdlog 사용법. 설치와 설정, 로거와 레벨, 콘솔·파일·로테이션 다중 싱크, 커스텀 포맷, 비동기 로깅, 싱크 생명주기와 스레드 안전성 실수, 동기 대비 성능과 구조화 로깅을 다룹니다.