Previous
Next
C++ 실전 가이드 시리즈 전체 목차 | #0~#49 기초·메모리·네트워크·면접

C++ 실전 가이드 시리즈 전체 목차 | #0~#49 기초·메모리·네트워크·면접

· 16분 읽기 · 수정
C++ 실전 가이드 시리즈 전체 목차 | #0~#49 기초·메모리·네트워크·면접

이 글의 핵심

C++의 표준·성능·ABI 맥락과 함께 #0~#49 목차를 안내합니다. 기초→STL·현대 C++→네트워크→실전·커리어·트러블슈팅까지 주제별 진입점을 짚습니다.

C++ 시리즈 완전 가이드: 학습 로드맵 (시리즈 소개)

이 시리즈는 C++ 문법·도구·런타임·배포를 한 궤도에 묶어, 읽을 수 있는 코드를 넘어 운용 가능한 시스템까지 확장하도록 구성되었습니다. #0~#10은 환경·빌드·메모리·동시성·예외·템플릿·STL로 공통 토대를 쌓고, #11~#20은 파일 I/O, auto/decltype, 람다, 이동·완벽 전달, 프로파일링·Sanitizer, CMake·테스트, 디자인 패턴으로 현대 C++ 품질을 끌어올립니다. #21~#30은 HTTP, Concepts, 코루틴, 모듈, Ranges, constexpr, Boost·스택 생태계, 소켓·Asio·TLS까지 I/O·프로토콜 축을 다루며, C++ 고성능 네트워크 가이드는 Asio·이벤트 루프·strand·핸들러 메모리 등 운영 난이도를 심화합니다. #31~#40은 실서버·DB·코테, 면접(가상·복사/이동·스마트 포인터·동시성), 언어 융합·GUI, C++23, 클린 코드·DOD, PMR, SIMD, vcpkg/Conan·CI/CD·Docker로 전개됩니다. #41~#49는 정적 분석·Fuzz, 임베디드·gRPC·관측·미래·커리어·딥다이브(예: Redis/HTTP/메모리 풀)와 Segfault, 링크 오류, Asio 데드락 트러블슈팅을 아우릅니다. 아래 링크 목차와 함께 읽으면, “어디서 시작하고 어디로 점프할지”를 시각적으로 고정할 수 있습니다.

flowchart LR
  subgraph A[초기 4주: 기초]
    a0["#0~2 언어·도구·컴파일"] --> a1["#3~5 IDE·CMake·빌드"]
    a1 --> a2["#6~10 메모리·동시성·예외·템플릿·STL"]
  end
  subgraph B[4~8주: 현대 C++ + 품질]
    b1["#11~14 I/O·타입·람다·이동"] --> b2["#15~18 성능·디버그·빌드·테스트"]
    b2 --> b3["#19~20 패턴"]
  end
  subgraph C[8~12주: 네트워크·비동기]
    c1["#21~27 HTTP·Concepts·코루틴·모듈·Ranges·Boost"] --> c2["#28~30 소켓·Asio·WebSocket·TLS"]
  end
  subgraph D[12주+: 실전·배포·도메인]
    d1["#31+ 서버·DB·면접"] --> d2["#38~45 설계·성능·DevOps·분석·임베디드·gRPC·커리어"]
    d2 --> d3["#48~49 프로젝트·트러블슈팅"]
  end
  A --> B --> C --> D

저는 C++을 이렇게 배웠습니다 (그리고 돌아가고 싶은 것들)

나는 먼저 문법을 외운다기보다, 빌드가 깨지면 아무것도 시작이 안 된다는 쪽에 시간을 썼다. “왜 이 심볼이 안 잡히지?” “왜 릴리스에서만 주?” 같은 걸 컴파일·링크·런타임으로 나눠서 붙잡는 습관이 생기기까지 꽤 돌아왔다. 돌이켜보면, 처음부터 ASan/TSan을 옆에 두고 C++에 들어갔다면 (그리고 vector+알고리즘을 코딩테스트 루틴으로 박아 뒀다면) 누수·데이터 경쟁 쪽에서 덜 흔들렸을 것이다. 모듈·코루틴은 언어보다 툴이 따라줄 때 붙이는 편이 싸움이 적었다. 지금은 “표준에 있는 건 다 써야지”가 아니라, 팀이 고정한 컴파일러·빌드·배포가 허락하는 범위 안에서 읽을 수 있는 계약을 쌓는 쪽이 편하다. 그래서 이 시리즈도 한 줄짜리 트릭보다, “나중에 운영·리뷰·장애 대응”까지 이어질 뼈대에 초점이 많이 간다. 돌아가고 싶은 지점? 빼기: UB에 너그러웠던 나 자신. 넣기: 측정·Sanitizer·최소 재현 케이스.

Learning resources I wish existed when I started

이건 상품이나 과외 얘기가 아니다. “처음 C++에 발을 담궜을 때, 어느 책/문서/영상이 있었으면 멘탈이 덜 갈렸을까”를 써 둔 메모다. 아래는 전부 개인 취향이고, 지금은 워낙 자료가 많아져서 일부는 이미 부분적으로 메워진 주제이기도 하다. 그럼에도 형태가 맞는 자료(한 장짜리 지도)는 여전히 희귀하다고 느낀다.

  • “링크 오류 3줄로 끝내기(현실 30줄)” 같은 것: 어느 .o가 어느 심볼을 들고 있고, 왜 링크 단계에서만 터지는지, 최소 CMake 타깃으로 어떻게 쪼개야 덜 미치는지를 한 흐름으로 잡는 자료. cppreference는 훌륭하지만, 이 문제는 링커라는 느낌을 목차로 먹여 주는 쪽이 필요했다. (지금은 이 시리즈의 #4~#5·#49-2 쪽이 그 구멍을 잠그려는 쪽에 가깝다.)
  • “Sanitizer 켜고 나서의 첫 주” 캡스톤: ASan/UBSan/TSan을 어떤 순서로 켜고, 어떤 이슈를 포기하고(노이즈/속도) 어떤 이슈를 먼저 잡는지, CI에선 어떤 조합이 현실적인지. 문서엔 플래그는 있는데, 첫 100개 경고를 줄이는 행동 루틴이 부족했었다. (→ #16·#18의 “빨간 CI를 친구로” 연습을 상상해 본다.)
  • “비동기 I/O: 콜백 10개를 1개의 스택 트레이스로” — 당시엔 각 API는 있었는데, 꼬임의 종류를 도식으로 잡는 자료는 적었다. strand, io_context thread affinity, post vs dispatch가 왜 생명과 연결되는지(데드락이 “운 나쁨”이 아니라 규칙으로 남는 이유)를 한 눈에. (→ C++ 네트워크 심화·#49-3 쪽이 그 지도다.)
  • “표준의 한 줄 + 컴파일러의 한 줄” 대조표: 같은 문장이 GCC/Clang/MSVC에서 경고/에러/침묵이 어떻게 갈리는지. C++는 표준과 현실(툴) 사이 틈이 큰 편인데, 처음엔 “내가 이상한가, 컴파일러가 이상한가, 둘 다인가”가 한데 섞인다. (이건 지금도 멘탈 관리가 필요하다. 컴파일러 릴리스 노트를 “선택지 목록”으로 읽는 습관이 생기면 꽤 낫다.)
  • “레거시 한 파일을 현대 C++로 옮기는 2주” — 리팩터가 아니라 최소 이동 시나리오(예: new → vector+RAII, raw loop → algorithm, typedef → using). “우아한 500편짜” 말고, PR이 작게 쪼개지는 리듬. (이 시리즈에선 #14~#20·#45-2 흐름이 그 방향을 닮았다고 본다.)

한 줄로 요약하면, 나는 문법책보다 “빌드·링크·런타임을 한 다이어그램으로 잡는 자료”와 “꼬인 비동기를 규칙으로 읽는 자료”가 더 빨리 있었으면 했다. 그 부족함을 줄이기 위해, 이 인덱스는 목차에 설계·운영·트러블슈팅의 비중을 꽤 넣었다.

이 시리즈에서 다루지 않는 것들과 그 이유

  • C++ “만으로” 3D 렌더링·쉐이더 파이프라인 전백까지 끌고 가는 식의 그래픽스 풀스택은, 본질이 API·수학·에셋 파이프라인인 경우가 많아 시리즈 밖 주제로 두었다. (다만 ImGui, 엔진 스케치, DOD·캐시 쪽은 #36·#39 등에서 연결점을 준다.)
  • Win32/유니버설 Windows 같은 플랫폼 API를 한 권에 끼워 넣지 않는다. 대신 CMake·크로스·배포·(필요 시) WSL2 전제를 문맥으로 깔고, “바이너리·경로·소켓 차이”에 에너지를 쓴다.
  • 특정 게임엔진(특정 상용 엔진) 전용 스크립팅·툴체인은 버전·라이선스·팀마다 너무 달라, 엔진 없이도 통하는 C++·빌드·성능·동시성으로 남기고 싶었다.
  • 기업/제품에 종속된 내부 프레임워크는 가져올 수가 없다. public 예제·문서·오픈소스와 표준·Boost·Asio 쪽에 맞췄다.
  • 모든 알고리즘·코테 유형의 최적 해만 정리하는 것도 목표가 아니다. #32는 “입력·문자열·복잡도”를 압축하는 쪽이고, 긴 #54 시리즈는 별도 트랙으로 두었다.

제가 추천하는 학습 순서

표로 박지 않을게. 대신 내가 실제로 후배한테 먼저 보내는 순서만 쓴다.

  • 앵커(막히면 여기): #0 → #1 → #2·#5 → #4 — 빌드·심볼·ODR이 안 잡히면 뒤는 다 공허하다.
  • 소유권·기본기: #6·RAII, #10~#10-3 — 코테에서 vector+lower_bound로 어느 정도 버티게 만든 다음 #7·#8로 동시성·예외를 엮는 편이 덜 멘붕 난다.
  • “현대 C++”로 읽는 법: #11#14를 지나, #15·#16·#18로 느리면 재고, 터지면 잡는 루프를 붙인다. 그다음에야 #19#20 패턴이 설계로 연결된다.
  • 서버·네트워크로 간다: #21#27를 한 번 훑고, #28#30 + C++ 네트워크 심화 — “콜백이 꼬이는 이유”는 여기서 풀린다. Concepts·Ranges·모듈·코루틴은 툴·팀이 OK 줄 때 골라 붙이면 된다(→ #22·#25·#24·#23).
  • 이직·면접·트러블슈팅: #33~#34·#46·#49 쪽은 뭔가 꼬였을 때 돌아와도 좋다. #31 이후는 “실서버 감”용.

흐름을 한 축으로만 말하자면: 언어(문법·의미) → STL·모던 표준 → 툴체인(빌드·의존성·품질) → 런타입(I/O·동시성·메모리) → (필요해지면) 조직·도메인 순이다. 위 링크가 그 순서에 대응하도록 대충 배치돼 있고, 세부는 아래 편 요약과 목차 쪽이 더 자세하다.

시리즈 각 편에서 읽을 것 (한 줄 힌트)

  • #0~#1: C++이 갖는 멀티 패러다임·ABI·도구 흐름의 큰 그림, IDE·컴파일러·디버거 설치, 프로젝트 루트·빌드 산출물의 위치를 익힙니다. #0 → #1
  • #2~#5: 전처리·컴파일·어셈블·링크 단계, 최적화 플래그, 크로스 컴파일 개념, ODR, 링크 타임 이슈의 출발점입니다. → #2 · #5
  • #6: 힙/스택, new/delete 대신 RAII·스마트 포인터로 소유권을 코드 구조에 맡기는 법, 누수·이중 해제·사이징. → #6 · #6 · #6
  • #7~#8: std::thread·mutex·condition_variable·atomic·메모리 순서(심화는 #34·#51-8 memory ordering), 예외 안전성·강·기본·노쇼 보장. → #7 · #8 · #8
  • #9~#10: 템플릿·가변 인자, SFINAE/Concepts로 이어지는 토대(→ #22), vector/string·연관·정렬/검색 알고리즘. → #9 · #10 · #10
  • #11~#14: 바이너리·텍스트 I/O, optional/variant 등 값 타입, 람다 캡처 함정, 이동·RVO·std::forward. → #12 · #13 · #14
  • #15~#18: 병목 측정 후 최적화, 캐시·컴파일 타임, GDB/LLDB, ASan/TSan, GTest·GMock. → #15 · #16 · #18
  • #19~#20: PIMPL(→ #38), 전략·옵저버·팩토리 등 팀이 자주 쓰는 패턴. → #19
  • #21~#30: REST/HTTP 클라, 코루틴(→ #23), 모듈·Ranges, constexpr 메타, Boost·nlohmann·spdlog, BSD 소켓·Asio·WebSocket·SSL.
  • #31~#37: 채팅/REST/DB 예제, 코테 입출력/문자열/STL 복잡도, 면접 가상/복제·shared_ptr/weak_ptr, C++23 맛보기, ImGui·Qt, 파일 API.
  • #38~#45: const/noexcept/[[nodiscard]], variant 다형성, 캐시·PMR·SIMD(→ #39), vcpkg·Conan, Clang-Tidy, Fuzz, 임베디드·gRPC·Prometheus, 커리어·로드맵. → #45-3
  • #46~#49: 시스템 설계·면접 50문·도메인별 역량·Go/Rust 비교, Redis/HTTP/메모리 풀 딥다이브, 세그폴트·CMake 링크·Asio 데드락(#49) 디버깅.

참고: “지금은 문법”이면 #0~#10을, “지금은 서버/네트워크”면 #28~#30 + 네트워크 심화를, “이직/면접”이면 #33~#34·#46을 병행해 읽는 식이 편하다. 번호는 교과서식 난이도가 아니라 당시 토픽 배치에 가깝다.

주제별 분류 (이 시리즈로 가는 링크)

  • 기초 (문법·타입): #0, #2(컴파일), #12 auto/optional, #32 입출력/문자열.
  • OOP (클래스·상속·다형성): #19~20 패턴, #33 가상·vtable, #38 variant 기반 합성, PIMPL. #33-1 · #38-2
  • 템플릿과 제네릭 (제약 기반): #9, #22 Concepts, #26 constexpr 메타. → #9 · #22
  • 메모리 (포인터·RAII·스마트 포인터): #6, #14, #33, #39 PMR·할당자, #48-3 딥다이브. → #6-3 · #39-2
  • STL (컨테이너·알고리즘·반복자): #10, #25 Ranges(현대적 알고리즘 뷰), #32 복잡도. → #10-3 · #25-1
  • 모던 C++ (C++11/14/17/20/23): #12~#14, #22~#26, #37, #44(미래). 모듈 #24 · 코루틴 #23 참고.
  • 동시성: #7, #29 멀티스레드 Asio, #34(면접 심화), 메모리 순서. → #7-1 · #29-3
  • 성능 최적화: #15(측정 우선), #39 캐시·SIMD, Core Guidelines(아래)와 데이터 지향(관련). → #15-2 · #39-3

주제 맵(한 줄씩): 기초에서 멈추면 객체 수명이 안 보이고(#6~#8·#14), OOP만 외우면 합성을 놓치기 쉬우니(#38-2, 패턴) 템플릿은 #9·#22로 제약을 읽을 수 있게 가져가는 편이 낫다. mutex만으로 데드락/레이스를 해결하려 하면 #34·Asio·memory ordering 쪽이 필요하고, 모듈·코루틴은 툴·ABI 합의가 먼저다.

실전 프로젝트 예시 (이 글/시리즈와 연결)

  • 게임/렌더링 엔진 스케치: 고정 틱·ECS·캐시 친화·리소스 로더 — [#48-1 game engine](관심 시 내부 링크·아키텍처)와 #39-1 DOD·Dear ImGui #36-1로 연결.
  • 시스템/서버·네트워크: Asio·strand·멀티스레드(→ 네트워크 가이드), gRPC/Protobuf, 채팅/REST(→ #31), Redis/HTTP/메모리 풀 딥다이브(→ #48).
  • 시스템 프로그래밍(리눅스): epoll 전 단계의 소켓·syscall 맥락(→ #42-3), 임베디드·MMIO(→ #42-2).

게임 엔진·프레임 드라이버 (요약 설계)

게임/엔진 쪽 실습을 시리즈와 연결할 때는 “한 프레임 안에서 무엇이 순서 보장을 받는가”를 먼저 씁니다. 통상 입력 샘플링 →(고정 틱) 시뮬레이션 → 렌더 (보간)로 나누고, 렌더와 시뮬의 Hz가 다르면 보간 버퍼를 둡니다. 데이터는 #39-1 DOD·SoA/ECS 맥락을 참고해 캐시 친화·콜드/핫 경로를 분리하고, 툴·UI는 Dear ImGui로 최소 디버그 패널을 붙이면 학습 루프가 짧아집니다. 대용량 자원 로딩·스트리밍은 I/O 쓰레드/잡(#50-3·#48 game)로 넘기고, 메인 스레드는 락 경합이 나지 않게 큐(작업/메시지)로만 통신하는 패턴이 흔합니다.

시스템/백엔드 (소켓·gRPC·관측)

시스템 프로그래밍 트랙은 “한 바이트가 어디서 막히는가”를 층으로 나눕니다: NIC→커널 버퍼→read/write→응용 버퍼→프로토콜 파서→비즈니스 로직. #28~30에서 에러·부분 read·TLS를 익힌 뒤, Asio로 콜백 체인을 경험하고, 운영 단계는 #43-3 메트릭으로 “큐 길이·지연 P99”를 붙이면 실서버 감이 잡힙니다. 마이크로서비스 간에는 #43-1 gRPC·스키마 진화(관련: Protocol Buffers)를 설계 스케치에 연결해 보십시오.

핵심 코드 스니펫 (미리보기)

소유권·예외 경계(개념):

#include <memory>
#include <vector>

// RAII: 스코프가 수명. 예외가 나가도 unique_ptr이 해제 루틴을 보장(소멸자).
void example(std::vector<int> data) {
  auto p = std::make_unique<std::vector<int>>(std::move(data));
  p->push_back(1);
} // p 소멸 → 힙 해제

동시성: 공유 자원에 대한 최소 락(개념) — 실전은 #7·TSan(→ #16)으로 검증합니다.

#include <mutex>
std::mutex g_mtx;
int g_count = 0;
void bump() {
  std::lock_guard<std::mutex> lock(g_mtx);
  ++g_count;
}

CMake 3줄 스케치(프로젝트 루트에서 확장) — 전체는 #4·#17.

cmake_minimum_required(VERSION 3.20)
project(demo LANGUAGES CXX)
add_executable(demo main.cpp)
target_compile_features(demo PRIVATE cxx_std_20)

Concepts로 제약을 읽을 수 있게(개념) — #22 흐름과 맞닿습니다. “이 타입에 size()가 있어야 한다”를 에러 메시지에 녹입니다.

#include <concepts>
#include <ranges>

template <class T>
concept SizedContainer = std::ranges::sized_range<T> && requires(T t) {
  { t.size() } -> std::convertible_to<std::size_t>;
};

template <SizedContainer C>
std::size_t byte_estimate(const C& c) { return c.size() * sizeof(typename C::value_type); }

std::span으로 API 경계에 크기를 묶기(개념) — 버퍼+길이 쌍 대신 연속 뷰로 의도를 드러냅니다(실무는 #12·Core Guidelines Bounds 힌트와 짝이 됨).

#include <span>
#include <vector>

void process(std::span<const std::byte> frame); // 호출 측: vector, 배열, 임시 모두에서 span 구성

void example() {
  std::vector<std::byte> buf(256);
  process(buf);
}

조건부 noexcept로 이동 연산·컨테이너에 힌트(개념) — 강한 예외 보장·vector 재할당과 연결(→ #14, #38-1). 팀마다 noexcept 정책이 다르므로 “왜”를 코멘트로 남깁니다.

#include <type_traits>
#include <vector>

struct Widget {
  std::vector<int> data;
  // 멤버 vector의 이동이 noexcept일 때 전체 이동도 noexcept로 *선언*해 컨테이너 최적화에 힌트
  Widget(Widget&&) noexcept(std::is_nothrow_move_constructible_v<std::vector<int>>) = default;
};

간단한 스코프 락(개념) — std::scoped_lock으로 여러 뮤텍스의 데드락을 피하는 기본기(→ #7, 심화는 lock 순서·계층).

#include <mutex>
std::mutex a, b;
void cross() {
  std::scoped_lock lock(a, b);  // C++17: 사전 정의된 lock 순서
  // critical section
}

도구 및 환경 (CMake, 컴파일러, 디버거, 패키지)

빌드는 CMake에 (팀이면) Ninja, 의존성은 vcpkg/Conan 쪽이 무난하다(→ #4·#17·#40-1). 컴파일러는 팀이 고른 GCC/Clang/MSVC 한 줄로 고정하고, 디버그는 GDB/LLDB에 ASan/TSan/UBSan을 붙이는 조합(→ #16-1·디버깅). IDE는 취향·플랫폼 문제라 VS Code·CLion·VS 가운데(#3 등), 정적 분석은 Clang-Tidy·Cppcheck(→ #41-1), 벤치는 perf·valgrind·heaptrack 류를 환경에 맞게(→ #15-1).

컴파일러 플래그(팀 합의 예시): 개발 빌드에 -O0 -g, 릴리스에 -O2/-O3 + LTO(거부감 낮을 때), 품질 게이트에 ASan/UBSan(일부 CI 잡). Windows·Linux 동시를 타깃이면 clang-cl+MSVC ABI 또는 순수 Clang 매트릭스를 먼저 정합니다(#2).

디버거·코어 덤프: Linux/macOS는 GDB/LLDB, 권한·심볼·-ggdb3·fPIC·strip 여부를 CI 아티팩트와 맞출 것(#16-1·#55-8). 코어가 크면 재현용 최소 바이너리 + 동일 libstdc++ 버전을 짝으로 붙입니다.

실무 팁(환경): Windows 네이티브에서 POSIX 예제를 다룰 때는 WSL2로 경로·소켓·poll/epoll 차이를 줄이는 편이 재현에 유리합니다(본문 #28 안내). ARM 크로스는 툴체인 파일(CMake) + sysroot + 런타임(libc)을 한 세트로 고정하십시오(#55-7 cross).

코딩 표준: C++ Core Guidelines (요약)

C++ Core Guidelines는 안전·단순·빠름의 균형을 규정이 아닌 권고로 정리한 문서입니다. 이 시리즈에서 반복 강조하는 것과의 대응은 대략 다음과 같습니다.

  • C.1–C.9(클래스): 불변식을 망가뜨리지 말 것 — RAII·생성/소멸(→ #6).
  • Con.1–4(constness): 가변을 최소화 — #38-1과 직접 연결. → const 가이드
  • E(safety/exception): 예외 안전·noexcept 사용 기준(→ #8-2·noexcept)
  • CP(concurrency): 공유·동기화 최소화·데이터 경쟁 금지 — #7·#34
  • ES(expressions): 미초기화·narrowing·unique_ptr·span·경계(→ #12·#6)
  • F(functions): 단일 책임·파라미터 최소·(필요 시) [[nodiscard]] — CppCoreGuidelines의 F·함수 절. 직관적으로 함수는 짧고, 오류는 expected(팀이 채택 시)나 예외/코드로 명시합니다.
  • I(interfaces): 추상화 비용을 이해하고, PIMPL로 컴파일 독립을 살(→ #38-3) 때는 인라인과의 트레이드오프를 주석에 남깁니다.
  • R(resource management): 취득即 초기화·소멸即 해제 — #6 RAII와 1:1. “소유권”을 타입으로 표현(unique_ptr vs raw pointer)하는 리뷰 루틴이 중요합니다.
  • P(pro): 프로덕션 대비로 로깅·assert·Defensive를 논하되, 성능·보안 이슈는 측정과 위협 모델을 함께 봅니다.

팀에 적용하는 법(요약): (1) Guidelines는 권고 — 위반 PR은 “사유(why)”가 없으면 반려하기 쉽습니다. (2) Clang-Tidy cppcoreguidelines-* 룰을 단계적 활성화(→ #41-1). (3) 코드리뷰에서 Guidelines·내부 스타일 가이드·ABI 정책을 같이 봅니다(→ #38-3 PIMPL). (4) 언어 옵션이 예외 끄기/RTTI 끄기인 임베디드는 별도 가이드를 씁니다.

실무 도메인 (게임, 임베디드, HFT)에서의 C++

게임 쪽이면 프레임 예산·DOD·잡 시스템·스크립트(→ Lua·Python) 냄새가 난다. 연결고리는 #36·#39-1 DOD·#48 game 쯤. 임베디드는 예외/RTTI off·static 금지 구역·MMIO가 생명줄(→ #42-1·#42-2). HFT/저지연은 캐시·지연 분포·락 피하기가 주제고, 측정 없이 손대지 말 것(→ #15·#34-2·#34-3 lock-free). 툴/파이프라인은 코드 생성·스크립트 쪽, 클라우드는 C++ 바이너리+이미지로 끌고 가는 쪽(→ #40-3·#50-5).

실무에서의 “같은 C++ 다른 팀”: 금융/게임/임베디드는 예외·동적 할당·로깅에 대한 허용 범위가 다르다. #46-3에 도메인별 흐름을 풀어 뒀다. 12주·24주짜리 주차 일정은 뺐다(표로 박는 건 내 스타일이 아냐). 대신 “지금 #몇 쯤 봐?”는 위 「제가 추천하는 학습 순서」를 먼저 봐라.

C++ 시리즈 학습 FAQ (보충) — 말편히

  • C랑 C++ 같이? C에서 포인터 감 익는 건 맞는데, C++는 vector·RAII 쪽이랑 스타일이 갈라져. malloc만 박다 보면 #6이랑 싸울 일 생김.
  • 바로 20/23? 문법 뼈대는 17/20 쪽이 편해. 모듈·코루틴·Ranges는 툴이 따라올 때 붙이는 게 싸움이 적지(→ #23~25·#24).
  • 템플릿 토나와 인스턴스가 언제 풀리는지만 잡고, SFINAE 지옥 말고 Concepts로 에러 읽을 수 있게 가져가(→ #22). 그게 훨씬 정신 건강에 좋음.
  • 스레드만 알면 끝? 끝이면 좋겠다. 메모리 모델·레이스·락 순서·이벤트 루프까지 엮어야 “가끔 터짐”이 줄어(→ #7, #29, #34, 네트워크).
  • 최적화 순서 측정 → 알고/자구 → 캐시·SIMD → 그 다음 마이크로. 순서 뒤집으면 시간 날림(→ #15).
  • 빌드가 제일 괴로워 CMake 표준·락 파일·CI부터 잡고, 링크 지옥은 #49-2에 심볼·ODR·런타임 냄새부터 맡아봐.
  • 스마트 포인터만? 소유권이 보이기 시작하면 반은 간 거고, shared_ptr 늪·순환·원자 이슈는 #33-3~#33-4·#34-3로 이어짐.
  • 모듈 import 언제? 빌드/서드파티가 소화할 때. 헤더만 있는 세상이면 마이그레이션·하이브리드가 현실.
  • 코루틴, Promise 외우기부터? 그러다 지친다. 써보기 먼저(비동기 I/O) → Why는 #23이랑 네트워크 코루틴을 같이 보면 퍼즐이 맞아 떨어짐.
  • UB 쓸모 있어? 쓸모 1도 없고 컴파일러가 뒤질 수 있는 구멍이야. Sanitizer+경고=에러로 박자(→ #16).
  • 참조 vs 포인터 null 없고 재바인딩 싫으면 참조, 아니면 optional·스마트 포인터(→ #12, Core I·F).
  • 팀이 Go/Rust로 간대 경계(FFI·소유권·스레드) 먼저 잡고 Rust·C++↔Rust 봐라. C++끼리 잘 쓴다고 경계가 자동으로 예쁘지는 않으니까.

C++ 시리즈 전체 목차

시리즈별 글 목록입니다. 아래 링크 중 일부는 비공개(draft) 상태일 수 있으며, 공개 후 링크가 활성화됩니다. 각 글에는 「이 글에서 다루는 키워드(관련 검색어)」가 있어, C++ 입문·컴파일러·메모리·STL·네트워크·면접 등 주제별로 검색할 때 참고하기 좋습니다. 예제 코드: 많은 글에서 복사·붙여넣기 후 바로 빌드·실행 가능한 예제를 제공합니다. 코드 블록 상단에 // 복사해 붙여넣은 뒤: g++ ... 형태의 빌드/실행 명령이 있으면, 해당 명령으로 컴파일 후 실행해 보시면 됩니다. (필요 시 -std=c++17·-std=c++20·-pthread·외부 라이브러리 경로 등은 글 안내를 따르세요.) 요구 환경: 대부분의 예제는 g++ 9+ / Clang 10+ (C++17), Linux 또는 macOS에서 동작합니다. 소켓·Asio 예제는 POSIX 환경(Linux/macOS) 또는 Windows에서는 WSL 권장. Boost·Google Test·spdlog 등이 필요한 글은 각 글 상단 또는 예제 주석에 설치 방법(vcpkg, 시스템 패키지 등)을 안내합니다. 처음이면: #0 C++이란? → #1 개발 환경 구축 → #2 컴파일러 순으로 읽으면 기초가 잡힙니다. 관심 주제별로 골라서 읽어도 되며, 네트워크·비동기는 #28 소켓·#29 Asio부터, 디버깅·성능은 #15~#16, 면접 대비는 #33~#34, #46를 참고하면 됩니다.

이 목차가 #0~#49까지 길게 이어지는 이유

C++는 시스템 한계에 가깝게 내려갈수록 힘을 쓰는 언어이면서, 동시에 표준 라이브러리·모듈·Concepts처럼 추상화 층도 두껍게 쌓아 온 언어입니다. 컴파일러가 생성하는 코드의 비용을 개발자가 예측할 수 있게 하려는 “제로 오버헤드 추상화” 철학 때문에, 메모리·동시성·링크·ABI 이야기가 문법만큼이나 중요합니다. 또한 게임·HFT·임베디드·백엔드처럼 도메인마다 금지 기능(예외 끔, RTTI 제한)과 빌드 파이프라인이 크게 달라, “한 가지 C++”로 통일하기 어렵습니다.

그래서 이 시리즈는 앞쪽 #1~#10에서 환경·컴파일·메모리·동시성·STL로 공통 기반을 만들고, #11~#30에서 현대 문법·Ranges·네트워크·Asio로 확장하며, #31 이후는 실전 서버·테스트·패턴·DevOps·보안·커리어·타 언어 비교처럼 팀과 배포를 포함한 주제로 넓어집니다. 번호가 커질수록 “문법 문제”보다 설계·운영·조직 비중이 커진다고 보면 기대치를 맞추기 좋습니다.

추천 경로

flowchart TB
  subgraph start[처음 읽기]
    S0[#0 C++이란]
    S1[#1 환경 구축]
    S2[#2 컴파일러]
    S0 --> S1 --> S2
  end
  subgraph topic[주제별]
    N[#28~29 네트워크]
    D[#15~16 디버깅]
    I[#33~46 면접]
  end
  S2 --> N
  S2 --> D
  S2 --> I

#0 — 시작 전

  • #0 C++이란? 역사, 현황

#1~#10 — 기초·환경·메모리·동시성·예외·템플릿·STL

  • #1 개발 환경 구축
  • #2 컴파일러 · 고급 · 최적화 · 비교
  • #3 VSCode 설정
  • #4 CMake 입문
  • #5 컴파일 과정
  • #6 메모리 누수 · 스마트 포인터 · RAII
  • #7 스레드 · mutex · condition_variable · atomic
  • #8 예외 · 예외 안전성 · 커스텀 예외
  • #9 템플릿 · 클래스 템플릿 · 가변 인자
  • #10 STL · map/set · 알고리즘

#11~#20 — 파일·타입·람다·이동·도구·패턴

  • #11 파일 I/O · 바이너리 직렬화 · stringstream
  • #12 auto/decltype · 범위 for · optional/variant/any
  • #13 람다 · 함수 객체
  • #14 이동 의미론 · 완벽 전달
  • #15 프로파일링 · 캐시 친화 · 컴파일 최적화
  • #16 디버거 · Sanitizer · 로깅/assert
  • #17 CMake 고급 · 패키지 매니저
  • #18 단위 테스트 · 모킹
  • #19 디자인 패턴 · 구조 패턴 · PIMPL/브릿지
  • #20 행동 패턴 · 디자인 패턴 종합

#21~#30 — HTTP·코루틴·Concepts·모듈·Ranges·네트워크

C++ 고성능 네트워크 가이드 (Asio 심화)

#31 — 실전 서버·DB

#32 — 코딩 테스트 압축

#33 — 면접: 객체지향·메모리

#34 — 면접 심화: 동시성·최적화

#35 — 타 언어 융합

#36 — GUI

#37 — C++23 프리뷰

#38 — C++ 아키텍처: 클린 코드와 설계 원칙

#39 — 고성능 C++: 하드웨어 최적화 심화

#40 — DevOps for C++: 빌드와 배포

#41 — 안정성 확보: 정적·동적 분석

#42 — 실전 도메인: 임베디드·시스템

#43 — 실전 도메인: 분산·보안·운영

#44 — C++의 미래

#45 — 커리어 가이드

#46 — 면접·시스템 설계·코테 확장

#47 — C++ vs 타 언어

#48 — 실전 딥다이브 프로젝트

#49 — 에러 해결·트러블슈팅

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

  • C++ 고성능 네트워크 가이드 시리즈 목차 | Boost.Asio·이벤트 루프·코루틴
  • Git 실전 가이드 시리즈 목차 | 기초·브랜치·원격·rebase
  • C++ 캐시 최적화 | 메모리 접근 패턴 바꿔서 성능 10배 향상시키기

이 글에서 다루는 키워드 (관련 검색어)

C++, 시리즈, 목차, 인덱스 등으로 검색하시면 이 글이 도움이 됩니다.

C++ 실무 팁 (목차만 보고 넘어가기 쉬운 것들)

  • 경고를 켜고 오류로 취급하는 습관(-Wall -Wextra -Werror 등 팀 합의)은 비용이 아니라 미래의 디버깅 시간을 줄이는 보험입니다. UB는 최적화 단계에서 조용히 바뀌기 쉽습니다.
  • 최적화 전에 프로파일합니다. 캐시 미스·할당·락 경합은 소스만 보고는 안 보이는 경우가 많습니다(#15 프로파일링과 연결).
  • RAII·스마트 포인터로 자원 경계를 코드 구조에 맞춥니다. “어디서 delete했더라?”보다 스코프로 말하게 하는 편이 장기적으로 안전합니다.
  • 동시성은 추측으로 락을 추가하지 않습니다. 데이터 레이스는 #7·#34와 Sanitizer로 검증하는 흐름이 정석에 가깝습니다.
  • 빌드·배포는 재현 가능하게 합니다. 같은 커밋이 CI와 로컬에서 다르면, 원인 추적이 지옥이 됩니다(#40 CI/CD 등).

내부 동작과 핵심 메커니즘

이 글의 주제는 「C++ 실전 가이드 시리즈 전체 목차 | #0~#49 기초·메모리·네트워크·면접」입니다. 여기서는 앞선 설명을 구현·런타임 관점에서 한 번 더 압축합니다. 시스템·런타임 경계(스케줄링, I/O, 메모리, 동시성)를 기준으로 생각하면, “입력이 어디서 검증되고, 핵심 연산이 어디서 일어나며, 부작용(I/O·네트워크·디스크)이 어디서 터지는가”가 한눈에 드러납니다.

처리 파이프라인(개념도)

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]

알고리즘·프로토콜: 디버깅할 때 눈에 두는 것

  • 불변 조건(Invariant): 각 단계가 만족해야 하는 조건(예: 버퍼 경계, 프로토콜 상태, 트랜잭션 격리)을 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
  • 결정성: 동일 입력에 동일 출력이 보장되는 순수한 층과, 시간·네트워크에 의해 달라질 수 있는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
  • 경계 비용: 직렬화/역직렬화, 문자 인코딩, syscall 횟수, 락 경합처럼 “한 번의 호출이 아니라 누적되는 비용”을 의심 목록에 넣습니다.

프로덕션 운영 패턴

실서비스에서는 관측·배포·보안·비용이 한꺼번에 온다. 딱 떨어지는 공식은 없는데, 자주 쓰는 질문은 이런 쪽이다. 관측은 상관 ID·에러율·지연 분위수·의존성 타임아웃이 보이냐, 안전은 입력·권한·시크릿이 경로마다 일관되냐, 신뢰는 멱등할 때만 재시도·백오프·서킷이 있냐, 성능은 캐시·배치·풀·백프레셔가 스케일에 맞냐, 배포는 롤백/카나리/마이그가 문서에 있냐.

운영에선 “로컬에선 절대”가 시간·부하·데이터만 바뀌면 터지기 쉬우니, 스테이징은 가능하면 현실 쪽에 가깝게 맞추는 게 낫다(그래도 100%는 없지).

문제 해결(Troubleshooting)

간헐 터짐은 보통 레이스·타임아웃·바깥 서비스 조합이니, 최소 재현이랑 트레이스부터. 느려진다면 N+1·동기 I/O·락·직렬화부터 의심하고, 프로파일/APM에서 한 덩이씩 뜯는다. 메모리만 계속 늘면 상한이랑 구독/이벤트 누수·불필요한 복제 쪽. 빌드/배포만 깨지면 환경·권한·버전 pin.

흐름은: 최소 재현 → 언제부터인지 → 의존성·env 차이 → 로그/메트릭으로 가설 → 고치고 회귀·부하. 말은 쉬운데, 현장은 3~4배 느리게 간다. 그게 정상에 가깝다.

자주 묻는 질문 (FAQ) — 아주 편한 말투

Q. 이거 실무에 언제 써?

A. 이 페이지는 인덱스야. “지금 C++ #몇 쯤 봐야 하지?” 할 때 쓰는 지도. 실무는 각 편이랑 위에 있는 「제가 추천하는 학습 순서」를 같이 봐.

Q. 뭐부터 읽는 게 제일 덜 꼬이냐?

A. #0·#1부터. 시리즈 글 밑에 이전/다음 있으면 그냥 그 느낌으로 따라가도 된다. 급하면 주제로 점프해도 OK.

Q. 표준/Asio/최신 방향은 어디 봄?

A. 언어·STL은 cppreference가 익숙해지기 좋고, Asio·Boost는 공식 문서를 같이. 최신 흐름은 WG21이랑 컴파일러 릴리즈 노트가 현실감이 있다(읽다가 머리 아프면 정상).

관련 글