C++ 시리즈 전체 목차: #0~#55 기초부터 고성능·분산 시스템까지

작성 0xmote · 2026년 2월 24일 · 20분 읽기 · 수정 2026년 9월 27일

시리즈 소개

C++ 언어의 기본 원리부터 대규모 시스템 설계까지를 #0~#55 번호로 나눠 다루는 시리즈이며, 아래 목차에서 73편의 글로 연결됩니다. 문법 나열보다 실무 환경에서 부딪히는 문제 해결에 집중합니다.

시리즈 특징

실무 중심의 구체적 해법
프로덕션 환경의 실제 문제(메모리 누수, 데이터 경쟁, 데드락, 성능 병목)에 대한 해결 방법과 구현 패턴을 다룹니다.

단계별 학습 경로
#0~#55의 주제가 학습 단계별로 설계되어 있습니다. 기초부터 순차적으로 진행할 수도 있고, 필요한 주제로 바로 접근할 수도 있습니다.

최신 C++ 표준 반영
C++11/14/17의 핵심 기능은 물론 C++20(Concepts, Ranges, Coroutines, Modules), C++23/26의 주요 변화와 레거시 코드 현대화 전략까지 포함합니다.

고성능 시스템 구축 기법
게임 엔진, 금융 시스템, 고성능 서버, 임베디드 등 도메인별 최적화 기법과 실전 예제를 제공합니다.

학습 로드맵: 4단계

flowchart TD
    subgraph Phase1[1단계: 기초 다지기 4-6주]
        A1[#0-2: 언어 개요·환경 설정·컴파일러] --> A2[#3-5: IDE·CMake·빌드 시스템]
        A2 --> A3[#6: 메모리 관리·RAII·스마트 포인터]
        A3 --> A4[#7: 멀티스레딩·동시성 기초]
        A4 --> A5[#8: 예외 처리·안전성]
        A5 --> A6[#9-10: 템플릿·STL 기초]
    end
    
    subgraph Phase2[2단계: 현대 C++ 6-8주]
        B1[#11-14: 파일 I/O·타입 추론·람다·이동 의미론] --> B2[#15-18: 프로파일링·디버깅·테스트]
        B2 --> B3[#19-20: 디자인 패턴·SOLID]
        B3 --> B4[#21-27: HTTP·Concepts·Coroutines·Ranges]
    end
    
    subgraph Phase3[3단계: 시스템 프로그래밍 8-12주]
        C1[#28-30: 네트워크·소켓·Asio·TLS] --> C2[#31-37: 실전 서버·DB·코테]
        C2 --> C3[네트워크 심화 시리즈]
        C3 --> C4[#38-45: 최적화·DevOps·도구]
    end
    
    subgraph Phase4[4단계: 전문가 수준 12주+]
        D1[#46-49: 면접·아키텍처·트러블슈팅] --> D2[#50-55: 고급 주제·도메인 특화]
        D2 --> D3[실전 프로젝트]
    end
    
    Phase1 --> Phase2 --> Phase3 --> Phase4

1단계: 기초 (4-6주)

목표: C++ 핵심 개념과 도구 체인 이해

C++의 주요 장벽인 빌드 시스템과 메모리 관리를 확실히 다집니다.

핵심 주제:

C++ 컴파일 과정: 전처리 → 컴파일 → 링크
CMake를 사용한 프로젝트 구성
메모리 모델: 스택 vs 힙, RAII 패턴
스마트 포인터: unique_ptr, shared_ptr, weak_ptr
멀티스레딩 기초: std::thread, mutex, condition_variable
STL 컨테이너와 알고리즘

실습 프로젝트:

간단한 메모리 관리자 구현
생산자-소비자 패턴 멀티스레드 큐
STL 기반 데이터 처리 파이프라인

2단계: 현대 C++ (6-8주)

목표: C++11/14/17/20의 핵심 기능 습득

현대 C++은 레거시 C++와 완전히 다른 언어라고 해도 과언이 아닙니다. 이 단계에서 C++의 표현력을 익힙니다.

핵심 주제:

이동 의미론과 완벽 전달
람다 표현식과 함수형 프로그래밍
Concepts를 활용한 템플릿 제약
Ranges 라이브러리로 우아한 데이터 처리
Coroutines로 비동기 코드 단순화
프로파일링 도구: perf, valgrind, gprof
정적 분석: Clang-Tidy, Cppcheck
동적 분석: AddressSanitizer, ThreadSanitizer

실습 프로젝트:

제네릭 컨테이너 라이브러리 구현
코루틴 기반 비동기 HTTP 클라이언트
템플릿 메타프로그래밍으로 컴파일 타임 계산기

3단계: 시스템 프로그래밍 (8-12주)

목표: 고성능 네트워크 서버와 시스템 소프트웨어 개발

실무에서 C++가 진가를 발휘하는 영역입니다. 네트워크 I/O, 동시성 제어, 성능 최적화의 모든 것을 다룹니다.

핵심 주제:

BSD 소켓 프로그래밍
Boost.Asio 비동기 I/O
I/O 멀티플렉싱: epoll, kqueue, IOCP
이벤트 루프 패턴
Strand를 사용한 동시성 제어
TLS/SSL 보안 통신
WebSocket 실시간 통신
데이터베이스 연동: MySQL, PostgreSQL, Redis

실습 프로젝트:

C++로 구현하는 고성능 채팅 서버
RESTful API 서버 프레임워크
분산 캐시 시스템
WebSocket 기반 실시간 대시보드

4단계: 전문가 수준 (12주 이상)

목표: 대규모 시스템 아키텍처와 도메인 전문성

이 단계에서는 복잡한 시스템을 설계하고, 팀을 리드하며, 기술 의사결정을 내릴 수 있는 역량을 갖춥니다.

핵심 주제:

시스템 아키텍처 설계 원칙
마이크로서비스와 분산 시스템
캐시 친화적 프로그래밍과 SIMD
메모리 풀과 커스텀 할당자
무잠금(Lock-free) 자료구조
도메인별 최적화: 게임, 금융, 임베디드
레거시 코드 현대화 전략
C++와 Rust/Go 비교 및 상호운용

실습 프로젝트:

Redis 클론 구현
HTTP 서버 엔진 구현
게임 엔진 기초 구조 설계
고빈도 거래(HFT) 시스템 시뮬레이터

시리즈 전체 목차 (#0~#55)

Part 1: 기초 (Foundation) - #0~#10

#0: C++ 언어 개요

C++의 역사와 설계 철학
멀티 패러다임 언어로서의 C++
ABI(Application Binary Interface) 이해
C++ 표준 라이브러리 생태계
C와의 호환성과 차이점
다른 시스템 프로그래밍 언어와의 비교
#0 보기

#1: 개발 환경 설정

IDE 선택과 설치: Visual Studio, CLion, VS Code
컴파일러 설치: GCC, Clang, MSVC
디버거 설정: GDB, LLDB, Visual Studio Debugger
패키지 관리자: vcpkg, Conan
프로젝트 구조 설계 Best Practices
빌드 산출물 관리 전략
#1 보기

#2-5: 컴파일과 빌드 시스템

#2: 컴파일러 기초와 최적화 옵션
- 전처리 단계: 매크로, 헤더 가드, include 경로
- 컴파일 단계: AST, 중간 표현(IR)
- 어셈블 단계: 기계어 생성
- 최적화 레벨: -O0, -O1, -O2, -O3, -Ofast
- 링크 타임 최적화(LTO)
- #2 보기
#3: IDE 활용과 생산성 도구
- 코드 네비게이션과 리팩토링
- 디버거 고급 기능: 조건부 중단점, Watch 표현식
- 프로파일러 통합
- 코드 포맷터: clang-format 설정
- #3 보기
#4: CMake 입문
- CMakeLists.txt 기본 구조
- 타깃(target) 기반 빌드 시스템
- 의존성 관리: find_package, FetchContent
- 크로스 플랫폼 빌드 전략
- 빌드 시스템 생성기: Ninja, Make
- #4 보기
#5: 컴파일과 링크 깊이 이해하기
- ODR(One Definition Rule) 이해
- 심볼 테이블과 이름 맹글링
- 정적 링크 vs 동적 링크
- 링크 오류 해결 전략
- 바이너리 분석 도구: nm, objdump, readelf
- #5 보기

#6: 메모리 관리

메모리 기초
- 스택 메모리: 자동 생명주기, 빠른 할당
- 힙 메모리: 동적 할당, 수동 관리
- 정적 메모리: 전역 변수, static 변수
- 메모리 레이아웃: 코드, 데이터, BSS, 힙, 스택
- #6-1 보기
메모리 누수 방지
- 일반적인 메모리 누수 패턴
- Valgrind로 메모리 누수 탐지
- AddressSanitizer 활용
- 스마트 포인터로 누수 방지
- #6-2 보기
스마트 포인터
- unique_ptr: 독점 소유권
- shared_ptr: 공유 소유권과 참조 카운팅
- weak_ptr: 순환 참조 해결
- 커스텀 삭제자(Custom Deleter)
- make_unique, make_shared 사용 이유
- #6-3 보기
RAII 패턴
- 리소스 획득은 초기화(Resource Acquisition Is Initialization)
- RAII로 예외 안전성 보장
- 스코프 가드 패턴
- RAII와 이동 의미론 결합
- #6-4 보기

#7: 멀티스레딩과 동시성

#7-1: 스레드 기초
- std::thread 생성과 조인
- 스레드 ID와 하드웨어 동시성
- 스레드 로컬 저장소
- 스레드 풀 패턴
- #7-1 보기
#7-2: 뮤텍스와 락
- std::mutex, std::recursive_mutex
- std::lock_guard, std::unique_lock
- std::scoped_lock (C++17)
- 락 프리 프로그래밍 소개
- 데드락 방지 전략
- #7-2 보기
#7-3: 조건 변수
- std::condition_variable 사용법
- Spurious Wakeup 처리
- 생산자-소비자 패턴 구현
- 세마포어와 배리어
- #7-3 보기

#8: 예외 처리와 안전성

#8-1: 예외 기초
- 예외 발생과 포착
- 예외 사양: noexcept
- 예외 클래스 계층 구조
- 커스텀 예외 클래스 설계
- #8-1 보기
#8-2: 예외 안전성 보장
- 강한 예외 안전성(Strong Exception Safety)
- 기본 예외 안전성(Basic Exception Safety)
- 무실패 보장(No-throw Guarantee)
- RAII와 예외 안전성
- Copy-and-Swap 관용구
- #8-2 보기

#9: 템플릿 프로그래밍

#9-1: 템플릿 기초
- 함수 템플릿
- 클래스 템플릿
- 템플릿 특수화(Specialization)
- 템플릿 인스턴스화 제어
- #9-1 보기
#9-2: 클래스 템플릿 심화
- 템플릿 템플릿 매개변수
- 의존 이름과 typename 키워드
- 템플릿 상속
- #9-2 보기
#9-3: 가변 인자 템플릿
- 파라미터 팩(Parameter Pack)
- 재귀적 템플릿 확장
- Fold Expressions (C++17)
- Perfect Forwarding과 결합
- #9-3 보기

#10: STL 컨테이너와 알고리즘

#10-1: 시퀀스 컨테이너
- std::vector: 동적 배열
- std::deque: 양방향 큐
- std::list: 이중 연결 리스트
- std::array: 고정 크기 배열 (C++11)
- std::string: 문자열 처리
- 컨테이너 선택 가이드
- #10-1 보기
#10-2: 연관 컨테이너
- std::map, std::multimap: 순서 있는 키-값 쌍
- std::set, std::multiset: 순서 있는 집합
- std::unordered_map, std::unordered_set: 해시 기반
- 커스텀 비교 함수와 해시 함수
- #10-2 보기
#10-3: STL 알고리즘
- 비-수정 알고리즘: find, count, for_each
- 수정 알고리즘: transform, replace, remove
- 정렬과 이진 검색: sort, binary_search, lower_bound
- 집합 연산: set_union, set_intersection
- 수치 알고리즘: accumulate, inner_product
- C++ STL 알고리즘 기초: sort·find·transform·accumulate 실전 활용

Part 2: 현대 C++ (Modern C++) - #11~#27

#11: 파일 I/O와 스트림

#11-1: 파일 I/O 기초
- std::ifstream, std::ofstream
- 텍스트 모드 vs 바이너리 모드
- 파일 포지션 제어
- 에러 처리 전략
- #11-1 보기
#11-2: 문자열 처리
- std::string vs std::string_view (C++17)
- 정규 표현식: std::regex
- 문자 인코딩: UTF-8, UTF-16, UTF-32
- 로케일(Locale) 처리
- #11-2 보기

#12: 타입 추론과 타입 안전성

#12-1: auto와 decltype
- auto 타입 추론 규칙
- decltype으로 표현식 타입 얻기
- AAA(Almost Always Auto) 스타일
- auto의 함정과 주의사항
- #12-1 보기
#12-2: 참조와 포인터
- 좌측값 참조 vs 우측값 참조
- 참조 붕괴(Reference Collapsing)
- 포인터 vs 참조 사용 가이드라인
- std::reference_wrapper
- #12-2 보기
#12-3: 옵셔널과 variant
- std::optional: 값이 없을 수 있는 타입
- std::variant: 타입 안전한 유니온
- std::any: 타입 지우기
- 패턴 매칭과 std::visit
- #12-3 보기

#13: 람다와 함수형 프로그래밍

#13-1: 람다 표현식
- 람다 문법과 캡처 목록
- 값 캡처 vs 참조 캡처
- 제네릭 람다 (C++14)
- 즉시 실행 람다(IIFE)
- #13-1 보기
#13-2: 함수 객체와 std::function
- 함수 객체(Functor) 패턴
- std::function으로 콜백 저장
- std::bind와 부분 적용
- 람다 vs 함수 객체 성능 비교
- #13-2 보기
#13-3: 컨테이너 선택 가이드
- 성능 특성 비교: 삽입, 삭제, 검색
- 메모리 레이아웃과 캐시 친화성
- 실무 시나리오별 컨테이너 선택
- #13-3 보기

#14: 이동 의미론과 완벽 전달

#14-1: 이동 의미론 기초
- 좌측값(lvalue) vs 우측값(rvalue)
- std::move의 의미와 사용
- 이동 생성자와 이동 대입 연산자
- Rule of Five
- #14-1 보기
#14-2: 완벽 전달(Perfect Forwarding)
- std::forward의 동작 원리
- 유니버설 참조(Universal Reference)
- 완벽 전달을 사용하는 팩토리 함수
- 전달 참조의 함정
- #14-2 보기

#15: 성능 측정과 최적화

#15-1: 프로파일링 도구
- perf: Linux 성능 분석
- Valgrind: 메모리와 캐시 프로파일링
- gprof: 함수 호출 그래프
- Visual Studio Profiler
- CPU 프로파일링 vs 메모리 프로파일링
- #15-1 보기
#15-2: 컴파일 타임 최적화
- 템플릿 인스턴스화 비용 줄이기
- Precompiled Headers (PCH)
- Unity Builds
- extern template 활용
- #15-2 보기

#16: 디버깅과 정적 분석

#16-1: GDB/LLDB 사용법
- 중단점과 감시점
- 스택 추적과 프레임 네비게이션
- 변수 검사와 메모리 덤프
- Core 덤프 분석
- #16-1 보기
#16-2: Sanitizers
- AddressSanitizer: 메모리 오류 탐지
- ThreadSanitizer: 데이터 경쟁 탐지
- UndefinedBehaviorSanitizer: UB 탐지
- MemorySanitizer: 초기화되지 않은 메모리 읽기
- CI/CD에 Sanitizers 통합
- #16-2 보기

#17: 고급 빌드 시스템

#17-1: CMake 고급 기능
- 타깃 속성과 전파
- Generator Expressions
- 커스텀 명령과 타깃
- CPack으로 패키징
- #17-1 보기
#17-2: 패키지 관리
- vcpkg: Microsoft의 C++ 패키지 관리자
- Conan: 크로스 플랫폼 패키지 관리
- 의존성 버전 관리 전략
- 사내 패키지 저장소 구축
- #17-2 보기

#18: 테스트와 품질 보증

#18-1: Google Test (GTest)
- 테스트 케이스와 픽스처
- 어서션(Assertion) 종류
- 파라미터화된 테스트
- 테스트 실행 옵션
- #18-1 보기
#18-2: Google Mock (GMock)
- Mock 객체 생성
- 동작 정의: EXPECT_CALL, WillOnce
- 매처(Matcher) 활용
- 의존성 주입과 테스트 가능한 설계
- #18-2 보기

#19-20: 디자인 패턴

#19-1: 생성 패턴
- Singleton: 단일 인스턴스 보장
- Factory Method: 객체 생성 위임
- Abstract Factory: 관련 객체군 생성
- Builder: 복잡한 객체 단계적 생성
- Prototype: 객체 복제
- #19-1 보기
#19-2: 구조 패턴
- Adapter: 인터페이스 변환
- Bridge: 구현과 추상화 분리
- Composite: 트리 구조 표현
- Decorator: 동적 기능 추가
- Facade: 서브시스템 간소화
- Proxy: 객체 접근 제어
- #19-2 보기
#20-1: 행위 패턴
- Observer: 이벤트 통지
- Strategy: 알고리즘 교체
- Command: 요청 캡슐화
- State: 상태 기반 동작 변경
- Template Method: 알고리즘 뼈대
- Visitor: 이중 디스패치
- #20-1 보기
#20-2: SOLID 원칙
- Single Responsibility: 단일 책임
- Open/Closed: 확장에는 열려있고 수정에는 닫혀있게
- Liskov Substitution: 치환 가능성
- Interface Segregation: 인터페이스 분리
- Dependency Inversion: 의존성 역전
- #20-2 보기

#21-27: HTTP, Concepts, Coroutines, Ranges

#21-1: HTTP 클라이언트 구현
- libcurl 활용
- HTTP 메서드: GET, POST, PUT, DELETE
- 헤더와 쿼리 파라미터
- JSON 직렬화/역직렬화
- #21-1 보기
#22-1: Concepts (C++20)
- 개념(Concept) 정의와 사용
- requires 절
- 표준 라이브러리 Concepts
- SFINAE를 Concepts로 대체
- #22-1 보기
#23-1: Coroutines (C++20)
- 코루틴 기초: co_await, co_yield, co_return
- Promise Type과 Coroutine Handle
- 제너레이터 구현
- 비동기 I/O와 코루틴
- #23-1 보기
#24-1: Modules (C++20)
- 모듈 기초와 import
- 헤더 유닛(Header Units)
- 모듈 인터페이스 vs 구현
- 빌드 시스템에 모듈 통합
- #24-1 보기
#25-1: Ranges (C++20)
- Ranges 라이브러리 소개
- Views: 지연 평가와 조합
- Pipeable 연산자: |
- 커스텀 Range 구현
- #25-1 보기
#26-1: constexpr 프로그래밍
- constexpr 함수와 변수
- 컴파일 타임 계산
- if constexpr (C++17)
- consteval (C++20)
- #26-1 보기
#27: 주요 오픈소스 라이브러리
- Boost: C++ 표준 라이브러리의 확장
- nlohmann/json: 모던 C++ JSON 라이브러리
- spdlog: 고성능 로깅
- fmt: 안전한 문자열 포매팅
- #27-1 보기

Part 3: 시스템 프로그래밍 - #28~#37

#28-30: 네트워크 프로그래밍

#28-1: 소켓 프로그래밍 기초
- TCP vs UDP
- 소켓 생성과 바인딩
- 클라이언트-서버 모델
- 논블로킹 I/O
- #28-1 보기
#29: Boost.Asio
- io_context와 이벤트 루프
- 비동기 읽기/쓰기
- 타이머와 스케줄링
- Strand로 동시성 제어
- 고성능 네트워크 심화 시리즈로 연결
- #29-1 보기
- 네트워크 심화 시리즈
#30: TLS/SSL과 WebSocket
- OpenSSL 통합
- TLS 핸드셰이크
- 인증서 검증
- WebSocket 프로토콜
- #30-1 보기

#31-32: 실전 프로젝트

#31-1: 채팅 서버 구현
- 멀티 클라이언트 처리
- 메시지 브로드캐스팅
- 세션 관리
- 에러 처리와 재연결
- #31-1 보기
#31-2: RESTful API 서버
- 라우팅 시스템
- 미들웨어 패턴
- 인증과 인가
- 데이터베이스 연동
- #31-2 보기
#32: 알고리즘과 코딩 테스트
- 빠른 입출력 기법
- STL 활용 패턴
- 시간 복잡도 최적화
- 주요 알고리즘 구현
- #32-1 보기

#33-37: 심화 개념과 면접 준비

#33: 객체 지향과 다형성
- 가상 함수와 Vtable
- 동적 바인딩 비용
- CRTP (Curiously Recurring Template Pattern)
- 타입 지우기(Type Erasure)
- #33-1 보기
#34: 동시성 심화
- 데이터 경쟁 탐지와 해결
- 원자적 연산과 메모리 순서
- 락 프리 자료구조 설계
- ABA 문제
- #34-1 보기
#35-36: 언어 통합과 GUI
- Python 바인딩: pybind11
- WebAssembly: Emscripten
- Dear ImGui: 즉시 모드 GUI
- Qt: 크로스 플랫폼 애플리케이션
- #35-1 보기
#37: C++23/26 미리보기
- std::expected: 에러 처리 개선
- Deducing this (C++23)
- Reflection (C++26 제안)
- 패턴 매칭 (C++26 제안)
- #37-1 보기

Part 4: 전문가 수준 - #38~#55

#38-40: 코드 품질과 최적화

#38: 클린 코드 원칙
- const correctness
- noexcept 사양
- [[nodiscard]] 속성
- 명시적 인터페이스 설계
- #38-1 보기
#39: 고성능 프로그래밍
- 캐시 친화적 설계
- Data-Oriented Design (DOD)
- SIMD 명령어 활용
- PMR (Polymorphic Memory Resources)
- #39-1 보기
#40: DevOps와 배포
- vcpkg와 Conan 심화
- GitHub Actions CI/CD
- Docker 컨테이너화
- 크로스 컴파일 전략
- #40-1 보기

#41-45: 도구와 도메인 특화

#41: 정적 분석
- Clang-Tidy 규칙 커스터마이징
- Cppcheck 통합
- 정적 분석을 CI에 통합
- 코드 커버리지 측정
- #41-1 보기
#42: 보안과 Fuzzing
- 보안 취약점 패턴
- 입력 검증과 sanitization
- Fuzzing 기초: AFL, libFuzzer
- OSS-Fuzz 통합
- #42-1 보기
#43: gRPC와 Protocol Buffers
- Protobuf 스키마 정의
- gRPC 서비스 구현
- 스트리밍 RPC
- 로드 밸런싱
- #43-1 보기
#44: 임베디드 시스템
- 임베디드 C++ 제약사항
- 메모리 제약 환경 최적화
- RTOS와의 통합
- 하드웨어 추상화 계층
- #44-1 보기
#45: 커리어와 레거시 현대화
- 레거시 코드베이스 리팩토링 전략
- 팀 코딩 표준 수립
- C++ 개발자 커리어 로드맵
- 오픈소스 기여 가이드
- #45-3 보기

#46-49: 면접과 트러블슈팅

#46: 기술 면접 대비
- 시스템 설계 면접
- 면접 단골 질문 50선
- 도메인별 차이점 (게임, 금융, 임베디드)
- 코딩 면접 전략
- #46-2 보기
#47: C++, Go, Rust 비교
- 메모리 모델 비교
- 동시성 모델 비교
- 성능 벤치마크
- 언어 간 상호운용
- #47-1 보기
#48: 대규모 프로젝트 딥다이브
- Redis 클론 구현
- HTTP 서버 엔진
- 메모리 풀 설계
- 캐싱 전략
- #48-1 보기
#49: 실전 트러블슈팅
- Segmentation Fault 디버깅
- CMake 링크 오류 해결
- Asio 데드락 진단
- 메모리 누수 추적
- #49-1 보기

#50-55: 고급 주제 (Advanced Topics)

#50: 분산 시스템
- 로드 밸런서 구현
- 분산 캐시 설계
- 합의 알고리즘: Raft, Paxos
- 서비스 메시 패턴
#51: 극한 성능 최적화
- 프로파일링 심화: perf, VTune
- SIMD 최적화 심화
- 멀티스레드 튜닝
- 메모리 순서 최적화
- 네트워크 I/O 최적화
#52: 대용량 데이터 처리
- Redis 연동
- PostgreSQL 연동
- Kafka 연동
- RabbitMQ 연동
- Protocol Buffers 심화
#53: 개발 도구
- CLion 고급 기능
- Visual Studio 심화
- vcpkg 패키지 제작
- Conan 레시피 작성
- CMake Presets
- 문서화 도구: Doxygen, Sphinx
#54: STL 알고리즘
- 모든 STL 알고리즘 상세 설명
- 성능 특성과 사용 시나리오
- 알고리즘 조합 패턴
#55: 전문가 주제 모음
- Reflection과 메타프로그래밍
- 코드 생성 기법
- 임베디드 최적화 심화
- 테스트 전략

학습 전략과 조언

초급자 (0-1년)

첫 3개월 목표: C++ 기본 문법과 도구 사용

기초 탄탄히: #0~#10을 순차적으로 학습
실습 위주: 각 주제마다 작은 프로젝트 구현
디버거 친구 만들기: 초기부터 GDB/LLDB 사용
Sanitizer 습관화: 모든 코드를 AddressSanitizer로 검증

권장 학습 흐름:

주 1-2: #0-1 (환경 설정)
주 3-4: #2-5 (컴파일 이해)
주 5-8: #6 (메모리 관리)
주 9-12: #7-10 (동시성, STL)

중급자 (1-3년)

목표: 현대 C++ 기능을 익히고 네트워크 프로그래밍 시작

현대 C++ 습득: #11~#27, 특히 이동 의미론, 람다, Ranges
네트워크 기초: #28~#30, Asio 비동기 I/O
실전 프로젝트: #31~#32, 채팅 서버, API 서버 구현
코드 품질: 정적 분석 도구 통합, 테스트 자동화

도전 과제:

멀티스레드 HTTP 서버 구현
Redis 프로토콜 호환 캐시 서버
고성능 JSON 파서

고급자 (3년 이상)

목표: 시스템 아키텍처 설계와 극한 성능 최적화

아키텍처: 마이크로서비스, 분산 시스템 설계
성능: SIMD, 캐시 최적화, 프로파일링 심화
도메인 전문성: 게임, 금융, 임베디드 중 선택
오픈소스 기여: 주요 C++ 프로젝트에 기여

종합 프로젝트:

분산 데이터베이스
게임 엔진 코어
고빈도 거래 시스템
실시간 스트리밍 서버

자주 묻는 질문 (FAQ)

Q: C++은 여전히 배울 가치가 있나요?

A: 절대적으로 그렇습니다. C++은:

게임 엔진: Unreal Engine, Unity 네이티브 플러그인
시스템 소프트웨어: OS 커널, 드라이버, 임베디드
고성능 서버: 금융, 실시간 스트리밍, 검색 엔진
과학 컴퓨팅: 머신러닝 백엔드, 시뮬레이션

에서 여전히 지배적입니다. 성능이 중요한 모든 곳에서 C++는 최고의 선택입니다.

Q: C++20/23의 새 기능을 꼭 배워야 하나요?

A: 점진적으로 배우는 것을 권장합니다. 실무에서는 아직 C++17이 가장 많이 사용됩니다. 하지만:

Concepts: 템플릿 에러 메시지 개선에 즉각적인 가치
Ranges: 코드 가독성과 표현력 대폭 향상
Coroutines: 비동기 코드 단순화

는 점진적으로 도입할 가치가 있습니다. Modules는 빌드 시스템 지원이 안정화될 때까지 기다리는 것이 현명합니다.

Q: 다른 언어 경험이 있습니다. 어디서부터 시작하나요?

A: 언어별로 다릅니다:

Java/C# 출신: #6(메모리), #14(이동 의미론)에 집중하세요. GC 없는 환경에 적응하는 것이 핵심입니다.
Python/JavaScript 출신: #2-5(컴파일)부터 시작하세요. 타입 시스템과 빌드 과정을 먼저 이해해야 합니다.
Go 출신: #7(동시성), #29(Asio)로 바로 가도 됩니다. 메모리 모델 차이는 이해해 두어야 합니다.
Rust 출신: #12(타입), #18(스마트 포인터)로 바로 넘어가도 됩니다. 멀티 패러다임 활용법을 익히는 데 집중하세요.

Q: 책 vs 온라인 vs 이 시리즈, 무엇이 최선인가요?

A: 조합이 최선입니다:

이 시리즈: 실무 중심, 한국어, 최신 동향
Effective C++ 시리즈 (Scott Meyers): 근본 원리
C++ Concurrency in Action (Anthony Williams): 동시성 심화
CppCon 영상: 최신 기법과 표준 변화
cppreference.com: API 레퍼런스

병행하면 시너지가 큽니다.

Q: 코딩 테스트에도 C++를 사용할 수 있나요?

A: 가능하며, 실제로 많은 경쟁 프로그래머들이 C++를 선호합니다:

장점: STL 알고리즘, 빠른 실행 속도, 정밀한 제어
단점: 긴 코드, 메모리 관리 실수 가능성
권장: #10(STL), #32(코테 최적화) 학습

Python이 더 간결하지만, C++로 숙달되면 시간 초과 문제에서 유리합니다.

학습 리소스와 커뮤니티

공식 문서와 참고 자료

cppreference.com: 가장 정확한 C++ 레퍼런스
C++ Core Guidelines: 모던 C++ 베스트 프랙티스
Compiler Explorer (Godbolt): 어셈블리 출력 확인

영상 자료

CppCon: 매년 열리는 최대 C++ 컨퍼런스
Jason Turner: C++ Weekly 시리즈
Klaus Iglberger: 디자인 패턴과 소프트웨어 아키텍처

온라인 커뮤니티

Reddit: r/cpp, r/cpp_questions
Stack Overflow: C++ 태그
C++ Slack/Discord: 실시간 질의응답

어디서부터 읽을지

C++가 처음이거나 오랜만에 돌아왔다면 #0: C++ 언어 개요부터 순서대로 읽는 것이 좋습니다. 이미 실무에서 C++를 쓰고 있다면 위 목차에서 지금 막힌 주제로 바로 이동해도 됩니다. 목적이 분명한 경우에는 아래에서 시작하세요.

고성능 네트워크: C++ 네트워크 심화 시리즈
면접 준비: #46-2: 면접 50문
크래시 트러블슈팅: #49-1: Segfault 디버깅

시리즈 소개

시리즈 특징

학습 로드맵: 4단계

1단계: 기초 (4-6주)

2단계: 현대 C++ (6-8주)

3단계: 시스템 프로그래밍 (8-12주)

4단계: 전문가 수준 (12주 이상)

시리즈 전체 목차 (#0~#55)

Part 1: 기초 (Foundation) - #0~#10

#0: C++ 언어 개요

#1: 개발 환경 설정

#2-5: 컴파일과 빌드 시스템

#6: 메모리 관리

#7: 멀티스레딩과 동시성

#8: 예외 처리와 안전성

#9: 템플릿 프로그래밍

#10: STL 컨테이너와 알고리즘

Part 2: 현대 C++ (Modern C++) - #11~#27

#11: 파일 I/O와 스트림

#12: 타입 추론과 타입 안전성

#13: 람다와 함수형 프로그래밍

#14: 이동 의미론과 완벽 전달

#15: 성능 측정과 최적화

#16: 디버깅과 정적 분석

#17: 고급 빌드 시스템

#18: 테스트와 품질 보증

#19-20: 디자인 패턴

#21-27: HTTP, Concepts, Coroutines, Ranges

Part 3: 시스템 프로그래밍 - #28~#37

#28-30: 네트워크 프로그래밍

#31-32: 실전 프로젝트

#33-37: 심화 개념과 면접 준비

Part 4: 전문가 수준 - #38~#55

#38-40: 코드 품질과 최적화

#41-45: 도구와 도메인 특화

#46-49: 면접과 트러블슈팅

#50-55: 고급 주제 (Advanced Topics)

학습 전략과 조언

초급자 (0-1년)

중급자 (1-3년)

고급자 (3년 이상)

자주 묻는 질문 (FAQ)

Q: C++은 여전히 배울 가치가 있나요?

Q: C++20/23의 새 기능을 꼭 배워야 하나요?

Q: 다른 언어 경험이 있습니다. 어디서부터 시작하나요?

Q: 책 vs 온라인 vs 이 시리즈, 무엇이 최선인가요?

Q: 코딩 테스트에도 C++를 사용할 수 있나요?

학습 리소스와 커뮤니티

공식 문서와 참고 자료

추천 도서

영상 자료

온라인 커뮤니티

어디서부터 읽을지

같이 보면 좋은 글