pkglog

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

작성 · · 20분 읽기 · 수정

시리즈 소개

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

시리즈 구성

각 글은 메모리 누수, 데이터 경쟁, 데드락, 성능 병목처럼 프로덕션에서 실제로 만나는 문제를 출발점으로 삼고, 그 문제를 푸는 구현 패턴을 설명합니다. 번호는 학습 순서를 따르므로 처음부터 차례로 읽어도 되고, 필요한 주제로 바로 건너뛰어도 됩니다.

표준 범위는 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++11 이후의 기능을 쓰면 소유권, 값의 이동, 템플릿 제약을 코드에 직접 표현할 수 있어서 같은 일을 하는 C++98 코드와 모양이 크게 달라집니다. 이 단계에서 그 표현 수단을 익힙니다.

핵심 주제:

  • 이동 의미론과 완벽 전달
  • 람다 표현식과 함수형 프로그래밍
  • 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 설정

  • #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 알고리즘

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

#31-32: 실전 프로젝트

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

  • #33: 객체 지향과 다형성

    • 가상 함수와 Vtable
    • 동적 바인딩 비용
    • CRTP (Curiously Recurring Template Pattern)
    • 타입 지우기(Type Erasure)
    • #33-1 보기

  • #34: 동시성 심화

  • #35-36: 언어 통합과 GUI

    • Python 바인딩: pybind11
    • WebAssembly: Emscripten
    • Dear ImGui: 즉시 모드 GUI
    • Qt: 크로스 플랫폼 애플리케이션

  • #37: C++23/26 미리보기

    • std::expected: 에러 처리 개선
    • Deducing this (C++23)
    • 정적 리플렉션 (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: 면접과 트러블슈팅

#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년)

처음 석 달은 기본 문법과 도구 사용에 익숙해지는 것을 목표로 잡습니다. #0~#10을 순서대로 읽되, 주제마다 작은 프로그램을 직접 만들어 보는 편이 기억에 오래 남습니다. 디버거(GDB/LLDB)는 처음부터 써 보는 것이 좋고, 연습 코드도 AddressSanitizer(-fsanitize=address)를 켜고 빌드하는 습관을 들이면 메모리 오류를 일찍 잡을 수 있습니다.

한 가지 예시 일정은 다음과 같습니다.

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

중급자 (1-3년)

현대 C++ 기능을 익히고 네트워크 프로그래밍을 시작하는 단계입니다. #11~#27에서는 특히 이동 의미론, 람다, Ranges를 확실히 이해해 두고, #28~#30으로 소켓과 Asio 비동기 I/O를 익힌 뒤 #31~#32의 채팅 서버와 API 서버를 직접 구현해 봅니다. 이 시기부터 정적 분석 도구와 테스트를 CI에 붙여 두면 코드가 커져도 품질을 유지하기 쉽습니다.

도전해 볼 만한 과제:

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

고급자 (3년 이상)

시스템 아키텍처 설계와 성능 최적화가 중심입니다. 분산 시스템 설계, SIMD와 캐시 최적화, 프로파일링 심화를 다루고, 게임·금융·임베디드 가운데 한 도메인을 골라 깊이 파고드는 것을 권합니다. 주요 C++ 오픈소스 프로젝트에 기여해 보는 것도 큰 코드베이스를 읽는 좋은 연습이 됩니다.

종합 프로젝트 예시:

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

자주 묻는 질문

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

그렇습니다. Unreal Engine 같은 게임 엔진, OS 커널과 드라이버·임베디드 같은 시스템 소프트웨어, 금융과 실시간 스트리밍 서버, 머신러닝 프레임워크의 백엔드와 시뮬레이션 코드에서 C++는 지금도 널리 쓰입니다. 다만 성능이 중요하다고 해서 항상 C++가 정답은 아니며, 메모리 안전성을 우선하는 신규 프로젝트에서는 Rust를, 서비스 개발 속도를 우선할 때는 Go 같은 언어를 함께 검토하는 것이 현실적입니다.

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

한꺼번에 익힐 필요는 없고 점진적으로 배우는 것을 권합니다. 실무 코드베이스는 아직 C++17을 기준으로 하는 곳이 많습니다. 그중에서도 Concepts는 템플릿 오류 메시지를 읽기 쉽게 만들어 주므로 효과가 바로 보이고, Ranges는 반복문 위주의 데이터 처리 코드를 짧게 만들어 주며, Coroutines는 콜백이 겹겹이 쌓이는 비동기 코드를 순차적인 모양으로 바꿔 줍니다. Modules는 CMake 3.28부터 정식 지원되지만 컴파일러와 도구별 지원 수준 차이가 아직 있으므로, 쓰는 툴체인에서 먼저 확인한 뒤 도입하는 편이 안전합니다.

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

Java나 C#에서 왔다면 #6(메모리)과 #14(이동 의미론)에 집중하세요. GC 없이 객체 수명을 직접 설계하는 데 적응하는 것이 핵심입니다. Python이나 JavaScript에서 왔다면 #2~#5(컴파일과 빌드)부터 읽어 정적 타입 시스템과 빌드 과정을 먼저 이해하는 것이 좋습니다. Go 경험이 있다면 #7(동시성)과 #29(Asio)로 바로 가도 되지만, C++ 메모리 모델과 수동 수명 관리의 차이는 짚고 넘어가야 합니다. Rust 경험이 있다면 소유권 개념이 이미 익숙하므로 #6-3(스마트 포인터)과 #12(타입 추론)를 빠르게 훑고, Rust와 달리 컴파일러가 막아 주지 않는 부분(댕글링 참조, 데이터 경쟁)을 중심으로 보면 됩니다.

책과 온라인 자료, 이 시리즈 중 무엇을 봐야 하나요?

하나만 고르기보다 함께 보는 편이 좋습니다. 이 시리즈로 실무 맥락을 잡고, Scott Meyers의 Effective C++ 계열 책으로 설계 원리를, Anthony Williams의 C++ Concurrency in Action으로 동시성을 깊이 보충하세요. 표준의 최신 변화는 CppCon 발표 영상에서, API의 정확한 동작은 cppreference.com에서 확인하는 것이 좋습니다.

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

가능하며, 경쟁 프로그래밍에서는 C++ 사용자가 많습니다. STL 알고리즘과 컨테이너가 잘 갖춰져 있고 실행 속도가 빨라 시간 제한에 여유가 생기는 반면, 코드가 길어지고 입출력 설정이나 정수 오버플로 같은 실수가 나기 쉽습니다. #10(STL)과 #32(입출력 최적화)를 먼저 보는 것을 권합니다. Python 코드가 더 짧지만, 시간 제한이 빠듯한 문제에서는 C++가 유리한 경우가 많습니다.

학습 리소스와 커뮤니티

공식 문서와 참고 자료

추천 도서

  • Effective Modern C++ - Scott Meyers
  • C++ Concurrency in Action - Anthony Williams
  • The C++ Programming Language - Bjarne Stroustrup
  • A Tour of C++ - Bjarne Stroustrup

영상 자료

  • CppCon: 매년 열리는 C++ 컨퍼런스, 발표 영상이 공개됩니다
  • Jason Turner의 C++ Weekly 시리즈
  • Klaus Iglberger의 디자인 패턴과 소프트웨어 아키텍처 발표

온라인 커뮤니티

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

어디서부터 읽을지

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

같이 보면 좋은 글