추가 적립 안내

『C++ 표준 라이브러리』는 C++11 표준과 새 표준에 따라 바뀐 라이브러리를 풍부한 예제와 함께 소개한 책이다. 표준 라이브러리를 사용하며 쉽게 겪을 수 있는 실수와 함정들을 친절하게 알려주므로 좀 더 높은 단계로 성장하고 싶어 하는 개발자들에게 적합하다. 표준 템플릿 라이브러리, 컨테이너, 반복자, 함수 객체와 STL 알고리즘에 초점을 맞추고 있다.

★ 요약 ★

더욱 사용하기 편해지고 기능도 더 많아진 C++11 표준과 새 표준에 따라 바뀐 라이브러리를 풍부한 예제와 함께 소개한다. C++11에 도입된 람다를 표준 템플릿 라이브러리와 알고리즘에 결합해 사용해보자. 정말 짧은 코드로도 가독성을 높이고 버그는 줄일 수 있을 것이다. 뿐만 아니라 표준 라이브러리를 사용하며 쉽게 겪을 수 있는 실수와 함정들을 친절하게 알려주므로 좀더 높은 단계로 성장하고 싶어 하는 개발자들에게 매우 적합한 책이다.

★ 이 책에서 다루는 내용 ★

■ 동시성
■ 분수 계산
■ 클럭과 타이머
■ 투플
■ 새 STL 컨테이너
■ 새 STL 알고리즘
■ 새 스마트 포인터
■ 새 로케일 패싯
■ 난수와 확률 분포
■ 데이터형 특질과 유틸리티
■ 정규 표현식

★ 이 책의 대상 독자 ★

이 책은 초급자를 위한 안내서이기도 하고 C++ 표준 라이브러리에 대한 체계화된 참고 매뉴얼이기도 하다. C++ 표준 라이브러리의 개별 컴포넌트에 대한 설명은 어느 정도 독립적이기 때문에 2장에서부터 5장까지를 읽고 난 다음에는 개별 컴포넌트를 설명하는 나머지 부분들을 독자가 원하는 어떤 순서로 읽어도 상관없다. 하지만 6장에서부터 11장까지는 같은 컴포넌트를 설명한다는 점을 기억하자. STL에 관한 다른 장들을 이해하려면 STL에 대한 소개가 나와 있는 6장에서부터 시작해야 할 것이다.

만약 여러분이 C++ 프로그래머이고, 라이브러리의 개념과 모든 부분에 대해 일반적으로 알고 싶다면, 그냥 처음부터 끝까지 읽어도 될 것이다. 하지만 참고 부분은 넘어가도 좋다. C++ 표준 라이브러리의 특정 컴포넌트를 사용하고 싶다면 ‘찾아보기’를 사용해서 찾는 게 가장 좋다.

★ 이 책의 구성 ★

처음 다섯 개 장에서는 이 책과 C++ 표준 라이브러리에 대해 전반적으로 소개한다.
1장, 개요: 이 책의 목적을 소개하고 내용을 설명한다.
2장, C++와 표준 라이브러리 소개: C++ 표준 라이브러리의 역사와 표준화의 내용에 대해 간단히 살펴보고 복잡도(complexity)라는 개념을 살펴본다.
3장, 새 언어 특성: 이 책을 읽고 C++ 표준 라이브러리를 사용하기 위해 알아야 하는 새 언어 특성들을 개괄적으로 살펴본다.
4장, 일반 개념: 4장은 모든 컴포넌트를 활용하기 위해서 알아야 하는 기본적인 라이브러리 개념을 설명한다. 특히 네임스페이스 std, 헤더 파일의 형식, 오류와 예외 처리에 대한 일반적인 지원에 대해서 소개한다.
5장, 유틸리티: 라이브러리의 사용자와 라이브러리 자체를 위해 제공되는 작은 유틸리티들을 소개한다. 특히 5장은 pair<>와 tuple<> 클래스, 스마트 포인터(smart pointer), 숫자의 한계(numeric limit), 데이터형 특질(type trait)과 데이터형 유틸리티, 보조 함수, ratio<> 클래스, 클럭(clock)과 타이머(timer), C++에서 사용할 수 있는 C 함수들을 알아본다.

6장에서부터 11장까지는 STL의 모든 것을 알아본다.
6장, 표준 템플릿 라이브러리: 데이터 모음을 처리하는 데 쓰이는 컨테이너 클래스와 알고리즘을 제공하는 STL의 개념에 대해 상세히 설명한다. 6장에서는 단계별로 개념을 설명하고, STL과 관련된 문제와 특별한 프로그래밍 기법에 대해서 알아본다. 또한 각 부분의 역할에 대해서도 살펴볼 생각이다.
7장, STL 컨테이너: STL이 제공하는 컨테이너 클래스의 개념과 제공하는 기능에 대해서 알아본다. 7장에서는 배열, 벡터(vector), 데크(deque), 리스트(list), 순방향 리스트(forward list), 집합(set), 맵(map), 비정렬 컨테이너(unordered container)가 가지는 공통 기능, 차이점, 특별한 활용점, 단점을 설명하고 전형적인 예를 살펴본다.
8장, STL 컨테이너 세부사항: 모든 컨테이너 멤버(데이터형과 연산)를 손쉽게 찾아볼 수 있는 형태로 설명한다.
9장, STL 반복자: 다양한 반복자 카테고리, 반복자를 위한 보조 함수뿐 아니라 스트림(stream) 반복자, 역방향 반복자, 삽입 반복자와 이동 반복자와 같은 다양한 반복자 어댑터(adapter)를 알아본다.
10장, STL 함수 객체와 람다(lambda) 사용: STL의 함수 객체 클래스(람다 포함)를 설명하고 이들을 사용해 컨테이너와 알고리즘의 동작을 정의하는 방법을 알아본다.
11장, STL 알고리즘: STL이 제공하는 알고리즘을 설명한다. 알고리즘을 간단하게 설명하고 비교한 후, 각 알고리즘을 다양한 예제 프로그램을 통해 상세히 설명했다.

12장에서부터 14장에서는 ‘단순한’ 개별 표준 클래스를 알아본다.
12장, 특별한 컨테이너: 큐(queue)와 스택(stack)을 위한 컨테이너 어댑터와 임의의 비트(bit)와 플래그(flag)들을 저장하는 비트필드(bitfield)를 관리하기 위한 비트셋(bitset) 클래스를 알아본다.
13장, 문자열: C++ 표준 라이브러리가 제공하는 여러 가지 문자열형(놀랍게도 문자열형은 하나가 아니다)을 살펴본다. 표준은 다양한 데이터형의 문자를 사용할 수 있도록 기본적인 데이터형 ‘종류’의 일부로서 문자열을 제공한다.
14장, 정규 표현식: 정규 표현식을 처리하기 위한 인터페이스(interface)를 설명한다. 정규 표현식은 문자와 하위 문자열을 찾고 치환하는 데 사용된다.

15, 16장에서는 I/O와 국제화라는 긴밀히 연관된 주제에 대해 다룬다.
15장, 스트림 클래스를 사용한 입력/출력: IOStream 라이브러리라고 알려진 컴포넌트를 다룬다. 15장은 일반적으로 잘 알려지지는 않았지만 프로그래머들에게는 중요할 수 있는 세부사항, 이를테면 특별한 I/O 채널(channel)을 정의하고 통합하는 방법도 함께 설명한다.
16장, 국제화: 프로그램을 국제화하기 위한 개념과 관련 클래스를 다룬다. 여기서는 다양한 문자 집합을 처리하는 법과 부동 소수점 숫자와 날짜를 다양한 형태로 제공하는 방법을 알아본다.

그 후에는 숫자, 동시성과 할당자를 알아본다.
17장, 숫자: C++ 표준 라이브러리의 숫자 컴포넌트를 설명한다. 특히 난수와 확률 분포를 제공하기 위한 클래스, 복소수를 위한 데이터형과 몇몇 C 수학 함수들을 알아본다.
18장, 동시성: 동시성과 멀티스레드를 지원하기 위해 C++ 표준 라이브러리에서 제공하는 특성을 설명한다.
19장, 할당자: C++ 표준 라이브러리내의 여러 가지 메모리 모델에 대한 개념을 설명한다.

1장 개요
___1.1 이 책이 나오게 된 이유
___1.2 이 책을 읽기 전
___1.3 이 책의 형식과 구조
___1.4 이 책을 어떻게 읽을 것인가
___1.5 현재 상황
___1.6 예제 코드와 부가 정보
___1.7 피드백

2장 C++와 표준 라이브러리 소개
___2.1 C++ 표준의 역사
______2.1.1 C++11 표준에 대한 일반적인 질문
______2.1.2 C++98과 C++11 호환성
___2.2 복잡도와 Big-O 표기법

3장 새 언어 특성
___3.1 새 C++11 언어 특성
______3.1.1 중요 세부 문법 정리
______3.1.2 auto로 자동 데이터형 추론
______3.1.3 통합된 초기화와 초기화자 목록
______3.1.4 범위 기반 for 루프
______3.1.5 이동 문맥과 Rvalue 참조자
______3.1.6 새 문자열 리터럴
______3.1.7 noexcept 키워드
______3.1.8 constexpr 키워드
______3.1.9 새로운 템플릿 특성
______3.1.10 람다
______3.1.11 decltype 키워드
______3.1.12 새로운 함수 선언 문법
______3.1.13 영역화된 열거형
______3.1.14 새로운 기본 데이터형
___3.2 오래된 ‘새’ 언어 특성
______3.2.1 기본 데이터형을 위한 명시적인 초기화
______3.2.2 main() 정의

4장 일반 개념
___4.1 네임스페이스 std
___4.2 헤더 파일
___4.3 오류와 예외 처리
______4.3.1 표준 예외 클래스
______4.3.2 예외 클래스의 멤버
______4.3.3 exception_ptr 클래스로 예외 전달
______4.3.4 표준 예외 던지기
______4.3.5 표준 예외 클래스에서 파생시키기
___4.4 호출 가능 객체
___4.5 동시성과 멀티스레딩에 대한 기본 개념
___4.6 할당자

5장 유틸리티
___5.1 쌍(Pair)과 투플(Tuple)
______5.1.1 Pair
______5.1.2 투플
______5.1.3 투플을 위한 I/O
______5.1.4 투플과 쌍사이의 변환
___5.2 스마트 포인터
______5.2.1 shared_ptr 클래스
______5.2.2 weak_ptr 클래스
______5.2.3 잘못된 공유 포인터 사용
______5.2.4 공유 포인터와 약한 포인터 세부 사항
______5.2.5 unique_ptr 클래스
______5.2.6 unique_ptr 클래스 상세
______5.2.7 auto_ptr 클래스
______5.2.8 스마트 포인터에 대한 맺음말
___5.3 숫자 한계
___5.4 데이터형 특질과 데이터형 유틸리티
______5.4.1 데이터형 특질의 목적
______5.4.2 데이터형 특질 상세
______5.4.3 참조자 래퍼
______5.4.4 함수형 래퍼
___5.5 보조 함수
______5.5.1 최소값과 최대값 처리
______5.5.2 두 값 맞바꾸기
______5.5.3 보충 비교 연산
___5.6 ratio<> 클래스를 통한 컴파일 시간 분수 계산
___5.7 시각과 타이머
______5.7.1 Chrono 라이브러리 개요
______5.7.2 기간
______5.7.3 클럭과 시간 지점
______5.7.4 C와 POSIX에서 제공하는 날짜와 시간 함수
______5.7.5 타이머로 멈추기
___5.8 헤더 파일 , 과
______5.8.1 내 정의
______5.8.2 내 정의
______5.8.3 내 정의

6장 표준 템플릿 라이브러리
___6.1 STL 컴포넌트
___6.2 컨테이너
______6.2.1 순서 컨테이너
______6.2.2 연관 컨테이너
______6.2.3 비정렬 컨테이너
______6.2.4 연관 배열
______6.2.5 다른 컨테이너
______6.2.6 컨테이너 어댑터
___6.3 반복자
______6.3.1 더 많은 연관 컨테이너와 비정렬 컨테이너 사용 예
______6.3.2 반복자 카테고리
___6.4 알고리즘
______6.4.1 범위
______6.4.2 다중 범위 처리
___6.5 반복자 어댑터
______6.5.1 삽입 반복자
______6.5.2 스트림 반복자
______6.5.3 역방향 반복자
______6.5.4 이동 반복자
___6.6 사용자 정의 일반 함수
___6.7 알고리즘 조작
______6.7.1 요소 ‘제거’
______6.7.2 연관 컨테이너와 비정렬 컨테이너 조작
______6.7.3 알고리즘 대 멤버 함수
___6.8 알고리즘 인자로써의 함수
______6.8.1 알고리즘 인자로 함수 사용하기
______6.8.2 조건자
___6.9 람다 사용하기
___6.10 함수 객체
______6.10.1 함수 객체 정의
______6.10.2 선정의 함수 객체
______6.10.3 바인더
______6.10.4 함수 객체와 바인더 대 람다
___6.11 컨테이너 요소
______6.11.1 컨테이너 요소의 요구사항
______6.11.2 값 문맥과 참조자 문맥
___6.12 STL 내 오류와 예외
______6.12.1 오류 처리
______6.12.2 예외 처리
___6.13 STL 확장하기
______6.13.1 다른 데이터형과 통합하기
______6.13.2 STL 형에서 파생시키기

7장 STL 컨테이너
___7.1 공통 컨테이너 기능과 연산
______7.1.1 컨테이너 기능
______7.1.2 컨테이너 연산
______7.1.3 컨테이너형
___7.2 배열
______7.2.1 배열의 기능
______7.2.2 배열 연산
______7.2.3 array를 C 배열로 사용하기
______7.2.4 예외 처리
______7.2.5 투플 인터페이스
______7.2.6 배열의 사용 예
___7.3 벡터
______7.3.1 벡터의 기능
______7.3.2 벡터 연산
______7.3.3 벡터를 C 형식 배열처럼 사용하기
______7.3.4 예외 처리
______7.3.5 벡터 사용 예제
______7.3.6 클래스 vector
___7.4 데크
______7.4.1 데크의 기능
______7.4.2 데크 연산
______7.4.3 예외 처리
______7.4.4 데크 사용 예
___7.5 리스트
______7.5.1 리스트의 기능
______7.5.2 리스트 연산
______7.5.3 예외 처리
______7.5.4 리스트 사용 예제
___7.6 순방향 리스트
______7.6.1 순방향 리스트의 기능
______7.6.2 순방향 리스트 연산
______7.6.3 예외 처리
______7.6.4 순방향 리스트 사용 예제
___7.7 집합과 다중 집합
______7.7.1 Abilities of Sets and Multisets
______7.7.2 집합과 다중 집합의 연산
______7.7.3 예외 처리
______7.7.4 집합과 다중 집합의 사용 예제
______7.7.5 실행 시간에 정렬 기준을 명시하는 예제
___7.8 맵과 다중 맵
______7.8.1 맵과 다중 맵의 기능
______7.8.2 맵과 다중 맵 연산
______7.8.3 맵을 연관 배열로 사용하기
______7.8.4 예외 처리
______7.8.5 맵과 다중 맵의 사용 예제
______7.8.6 맵, 문자열, 실행 시간 정렬 기준 예제
___7.9 비정렬 컨테이너
______7.9.1 비정렬 컨테이너의 기능
______7.9.2 비정렬 컨테이너 생성과 제어
______7.9.3 그 외 비정렬 컨테이너 연산
______7.9.4 버킷 인터페이스
______7.9.5 비정렬 맵을 연관 배열로 사용하기
______7.9.6 예외 처리
______7.9.7 비정렬 컨테이너 사용 예제
___7.10 그 외 STL 컨테이너
______7.10.1 STL 컨테이너로써의 문자열
______7.10.2 STL 컨테이너로써의 일반 C 형식 배열
___7.11 참조자 문맥 구현
___7.12 언제 무슨 컨테이너를 쓸 것인가

8장 STL 컨테이너 멤버 상세
___8.1 데이터형 정의
___8.2 생성, 복사와 소멸 연산
___8.3 수정하지 않는 연산들
______8.3.1 크기 연산
______8.3.2 비교 연산
______8.3.3 연관 컨테이너와 비정렬 컨테이너를 위한 수정하지 않는 연산들
___8.4 할당
___8.5 직접 요소 접근
___8.6 반복자를 만드는 연산
___8.7 요소 삽입과 제거
______8.7.1 단일 요소 삽입
______8.7.2 다중 요소 삽입
______8.7.3 요소 삭제
______8.7.4 크기 조절
___8.8 리스트와 순방향 리스트를 위한 특별한 멤버 함수
______8.8.1 리스트(와 순방향 리스트)를 위한 특별한 멤버 함수
______8.8.2 순방향 리스트만의 특별한 멤버 함수
___8.9 컨테이너 정책 인터페이스
______8.9.1 수정하지 않는 정책 함수
______8.9.2 수정 정책 함수
______8.9.3 비정렬 컨테이너의 버킷 인터페이스
___8.10 할당자 지원
______8.10.1 기본 할당자 멤버
______8.10.2 할당자 파라미터를 추가로 받는 생성자

9장 STL 반복자
___9.1 반복자를 위한 헤더 파일
___9.2 반복자 카테고리
______9.2.1 출력 반복자
______9.2.2 입력 반복자
______9.2.3 순방향 반복자
______9.2.4 양방향 반복자
______9.2.5 임의 접근 반복자
______9.2.6 벡터 반복자의 증가, 감소 문제
___9.3 보조 반복자 함수
______9.3.1 advance()
______9.3.2 next()와 prev()
______9.3.3 distance()
______9.3.4 iter_swap()
___9.4 반복자 어댑터
______9.4.1 역방향 반복자
______9.4.2 삽입 반복자
______9.4.3 스트림 반복자
______9.4.4 이동 반복자
___9.5 반복자 특질
______9.5.1 반복자를 위한 일반 함수 작성
___9.6 사용자 정의 반복자 만들기
___
___10장 STL 함수 객체와 람다 사용
___10.1 함수 객체의 개념
______10.1.1 정렬 기준으로써의 함수 객체
______10.1.2 내부 상태를 갖는 함수 객체
______10.1.3 for_each()의 반환값
______10.1.4 조건자 대 함수 객체
___10.2 선정의된 함수 객체와 바인더
______10.2.1 선정의된 함수 객체
______10.2.2 함수 어댑터와 바인더
______10.2.3 함수 어댑터를 위한 사용자 정의 함수 객체
______10.2.4 폐기 예정인 함수 어댑터
___10.3 람다 사용
______10.3.1 람다와 바인더 비교
______10.3.2 람다 대 상태가 있는 함수 객체
______10.3.3 람다로 전역과 멤버 함수 호출하기
______10.3.4 람다를 해시 함수, 정렬이나 동등성 검사 기준으로 사용하기

11장 STL 알고리즘
___11.1 알고리즘 헤더 파일
___11.2 알고리즘 개요
______11.2.1 간단한 소개
______11.2.2 알고리즘 분류
___11.3 보조 함수
___11.4 for_each() 알고리즘
___11.5 수정하지 않는 알고리즘
______11.5.1 요소 수 세기
______11.5.2 최소와 최대
______11.5.3 검색
______11.5.4 범위 비교
______11.5.5 범위를 위한 조건자
___11.6 수정 알고리즘
______11.6.1 요소 복사
______11.6.2 요소 이동
______11.6.3 요소 변환과 결합 변환
______11.6.4 요소 교환
______11.6.5 새로운 값 할당
______11.6.6 요소 치환 - 수열 내 값 치환
___11.7 제거 알고리즘
______11.7.1 특정 값 제거
______11.7.2 중복된 값 제거
___11.8 변이 알고리즘
______11.8.1 요소의 순서 뒤집기
______11.8.2 요소 순환
______11.8.3 요소 순서 교환
______11.8.4 요소 순서 섞기
______11.8.5 요소를 앞으로 이동시키기
______11.8.6 두 하위 범위로 분할
___11.9 정렬 알고리즘
______11.9.1 모든 요소 정렬
______11.9.2 부분 정렬
______11.9.3 n번째 요소에 따라 정렬하기
______11.9.4 힙 알고리즘
___11.10 정렬된 범위 알고리즘
______11.10.1 요소 검색
______11.10.2 요소 병합
___11.11 숫자 알고리즘
______11.11.1 결과 처리
______11.11.2 상대값과 절대값 사이 변환

12장 특수 컨테이너
___12.1 스택
______12.1.1 핵심 인터페이스
______12.1.2 스택의 사용 예
______12.1.3 사용자 정의 스택 클래스
______12.1.4 stack<> 클래스 세부사항
___12.2 큐
______12.2.1 핵심 인터페이스
______12.2.2 큐의 사용 예
______12.2.3 사용자 정의 큐 클래스
______12.2.4 queue<> 클래스 세부사항
___12.3 우선순위 큐
______12.3.1 핵심 인터페이스
______12.3.2 우선순위 큐의 사용 예
______12.3.3 priority_queue<>클래스 세부사항
___12.4 컨테이너 어댑터 세부사항
______12.4.1 데이터형 정의
______12.4.2 생성자
______12.4.3 우선순위 큐를 위한 보완 생성자
______12.4.4 연산
___12.5 비트세트
______12.5.1 비트세트 사용 예
______12.5.2 클래스 bitset 세부사항

13장 문자열
___13.1 문자열 클래스의 목적
______13.1.1 첫 번째 예제: 임시 파일이름 추출
______13.1.2 두 번째 예제: 단어를 추출하고 거꾸로 출력하기
___13.2 문자열 클래스 설명
______13.2.1 문자열 데이터형
______13.2.2 연산 개요
______13.2.3 생성자와 소멸자
______13.2.4 문자열과 C 문자열
______13.2.5 크기와 용량
______13.2.6 요소 접근
______13.2.7 비교
______13.2.8 수정자
______13.2.9 하위 문자열과 문자열 연결
______13.2.10 입력/출력 연산자
______13.2.11 검색과 찾기
______13.2.12 npos라는 값
______13.2.13 숫자 변환
______13.2.14 문자열을 위한 반복자 지원
______13.2.15 국제화
______13.2.16 성능
______13.2.17 문자열과 벡터
___13.3 문자열 클래스 세부사항
______13.3.1 데이터형 정의와 정적 값
______13.3.2 생성, 복사, 소멸 연산
______13.3.3 크기와 용량 관련 연산
______13.3.4 비교
______13.3.5 문자 접근
______13.3.6 C 문자열과 문자 배열 생성
______13.3.7 수정 연산
______13.3.8 검색과 찾기
______13.3.9 하위 문자열과 문자열 결합
______13.3.10 입력/출력 함수
______13.3.11 숫자 변환
______13.3.12 반복자 생성
______13.3.13 할당자 지원

14장 정규 표현식
___14.1 Regex 일치와 검색 인터페이스
___14.2 하위 표현식 다루기
___14.3 Regex 반복자
___14.4 Regex 토큰 반복자
___14.5 정규 표현식으로 치환
___14.6 Regex 플래그
___14.7 Regex 예외
___14.8 Regex ECMAScript 문법
___14.9 다른 문법
___14.10 기초 정규 표현식 서명 세부사항

15장 스트림 클래스를 사용한 입력/출력
___15.1 I/O 스트림에 대한 공통 기본 지식
______15.1.1 스트림 객체
______15.1.2 스트림 클래스
______15.1.3 전역 스트림 객체
______15.1.4 스트림 연산자
______15.1.5 조작자
______15.1.6 간단한 예제
___15.2 기초적인 스트림 클래스와 객체
______15.2.1 클래스와 클래스 계층 구조
______15.2.2 전역 스트림 객체
______15.2.3 헤더 파일
___15.3 표준 스트림 연산자 <<와 >>
______15.3.1 출력 연산자 <<
______15.3.2 입력 연산자 >>
______15.3.3 특수 문자 입력/출력
___15.4 스트림의 상태
______15.4.1 스트림의 상태를 표현하는 상수값
______15.4.2 스트림의 상태에 접근하는 멤버 함수
______15.4.3 스트림 상태와 불리언 조건
______15.4.4 스트림 상태와 예외
___15.5 표준 입력/출력 함수
______15.5.1 입력을 위한 멤버 함수
______15.5.2 출력을 위한 멤버 함수
______15.5.3 사용법 예제
______15.5.4 sentry 객체
___15.6 조작자
______15.6.1 조작자 전체 개요
______15.6.2 조작자는 어떻게 동작하는가
______15.6.3 사용자 정의 조작자
___15.7 형식 맞추기
______15.7.1 형식 플래그
______15.7.2 불리언 값의 입력/출력 형식
______15.7.3 너비, 채움 문자와 조정
______15.7.4 더하기 부호와 대문자
______15.7.5 숫자 진수
______15.7.6 부동 소수점 표기법
______15.7.7 일반 형식 정의
___15.8 국제화
___15.9 파일 접근
______15.9.1 파일 스트림 클래스
______15.9.2 파일 스트림을 위한 Rvalue와 이동 문맥
______15.9.3 파일 플래그
______15.9.4 임의 접근
______15.9.5 파일 기술자 사용하기
___15.10 문자열을 위한 스트림 클래스
______15.10.1 문자열 스트림 클래스
______15.10.2 문자열 스트림을 위한 이동 문맥
______15.10.3 char* 스트림 클래스
___15.11 사용자 정의 데이터형을 위한 입력/출력 연산자
______15.11.1 출력 연산자 구현
______15.11.2 입력 연산자 구현
______15.11.3 보조 함수를 사용하는 입력/출력
______15.11.4 사용자 정의 형식 플래그
______15.11.5 사용자 정의 입력/출력 연산자에 대한 관행
___15.12 입력과 출력 스트림 연결
______15.12.1 tie()를 사용한 느슨한 연결
______15.12.2 스트림 버퍼를 사용한 밀접한 동조화
______15.12.3 표준 스트림 리다이렉션
______15.12.4 읽고 쓰기를 위한 스트림
___15.13 스트림 버퍼 클래스
______15.13.1 스트림 버퍼 인터페이스
______15.13.2 스트림 버퍼 반복자
______15.13.3 사용자 정의 스트림 버퍼
___15.14 성능 문제
______15.14.1 C의 표준 스트림과 동기화
______15.14.2 스트림 버퍼에서의 버퍼링
______15.14.3 스트림 버퍼 직접 사용하기

16장 국제화
___16.1 문자 인코딩과 문자 집합
______16.1.1 다중 바이트와 넓은 문자 글
______16.1.2 다양한 문자 집합
______16.1.3 C++내 문자 집합 다루기
______16.1.4 문자 특질
______16.1.5 특수 문자의 국제화
___16.2 로케일의 개념
______16.2.1 로케일 사용
______16.2.2 로케일 패싯
___16.3 로케일 세부사항
___16.4 패싯 세부사항
______16.4.1 숫자 형식 맞추기
______16.4.2 통화 형식
______16.4.3 시간과 날짜 형식
______16.4.4 문자 분류와 변환
______16.4.5 문자열 대조
______16.4.6 국제화된 메시지

17장 수학
___17.1 난수와 확률 분포
______17.1.1 첫 번째 예제
______17.1.2 엔진
______17.1.3 엔진 세부사항
______17.1.4 확률 분포
______17.1.5 확률 분포 세부사항
___17.2 복소수
______17.2.1 클래스 complex<> 일반
______17.2.2 클래스 complex<>를 사용하는 예제
______17.2.3 복소수의 연산
______17.2.4 클래스 complex<> 상세
___17.3 전역 수학 함수
___17.4 값 배열(valarray)

18장 동시성
___18.1 상위 계층 인터페이스: async()와 미래(future)
______18.1.1 async()와 미래를 사용한 첫 번째 예제
______18.1.2 두 작업을 기다리는 예제
______18.1.3 공유 미래
___18.2 하위 계층 인터페이스: 스레드와 약속
______18.2.1 클래스 std::thread
______18.2.2 약속
______18.2.3 클래스 packaged_task<>
___18.3 스레드 시작에 대한 세부 설명
______18.3.1 async() 세부사항
______18.3.2 미래 세부사항
______18.3.3 공유 미래 세부사항
______18.3.4 클래스 std::promise 세부사항
______18.3.5 클래스 std::packaged_task 세부사항
______18.3.6 클래스 std::thread 세부사항
______18.3.7 네임스페이스 this_thread
___18.4 스레드 동기화, 혹은 동시성의 문제
______18.4.1 동시성 조심!
______18.4.2 동시 데이터 접근 문제가 발생하는 이유
______18.4.3 정확히 무엇이 잘못될 수 있나(문제의 범위)
______18.4.4 문제를 해결하기 위한 특성
___18.5 뮤텍스와 잠금
______18.5.1 뮤텍스와 잠금 사용
______18.5.2 뮤텍스와 잠금 세부사항
______18.5.3 여러 스레드에서 한 번 호출
___18.6 조건 변수
______18.6.1 조건 변수의 목적
______18.6.2 조건 변수를 사용하는 첫 번째 완전한 예제
______18.6.3 다중 스레드를 위한 큐를 구현하기 위해 조건 변수 사용하기
______18.6.4 조건 변수 세부사항
___18.7 원자
______18.7.1 원자 사용 예
______18.7.2 원자와 상위 계층 인터페이스 세부사항
______18.7.3 원자에 대한 C 형식의 인터페이스
______18.7.4 원자의 하위 계층 인터페이스

19장 할당자
___19.1 애플리케이션 개발자로서 할당자 쓰기
___19.2 사용자 정의 할당자
___19.3 라이브러리 프로그래머로서 할당자 사용

★ 저자 서문 ★

나는 첫 판이 그렇게나 오랫동안 팔릴 줄은 생각도 못했었다. 하지만, 이제 12년이나 지났으니 새로운 C++ 표준인 C++11을 다루는 새로운 책이 필요다.

새로운 라이브러리가 추가된 것 정도가 아니라는 걸 알아두자. C++ 자체가 바뀌었다. 지금 보기에 일부 라이브러리를 쓰는 전형적인 대부분의 애플리케이션은 크게 바뀐 것 같지 않을 것이다. 이건 언어가 크게 바뀌었기 때문은 아니다. rvalue 참조라든지, 이동 문맥, 범위 기반 for 루프, auto와 새로운 템플릿 특성들처럼 수많은 작은 부분들이 바뀐 결과다. 새로운 라이브러리나 이미 있던 라이브러리의 보조 특성을 소개하는 대신, 이 책의 거의 모든 예제를 최소한 부분적으로나마 다시 작성했다. 그렇긴 하더라도 여전히 ‘오래된’ C++ 환경을 사용하는 프로그래머들을 위해 C++ 버전들간의 차이점이 보일 때마다 그 차이를 설명했다.

나는 C++11을 쉽게 배우지 못했다. 새로운 표준화가 진행 중일 때 따라잡지 못하고, 약 2년 전에서나 C++11을 알아보기 시작했기 때문이다. 정말 이해하기 힘들었다. 하지만 표준화 위원회에 속한 많은 사람들이 새로운 특성과 자신이 사용되길 바라는 방향에 대해 잘 설명해줬다.

마지막으로, 이 책에서의 어려움을 알아줬으면 한다. 이 책이 800쪽에서 1,100쪽으로 (번역서는 859쪽에서 1,152쪽) 늘어나긴 했지만 C++11 표준 라이브러리 전체를 소개하진 못했다. 새 C++11 표준의 라이브러리 부분 자체만으로도 750쪽 가까이 된다. 그다지 설명도 많지 않고 압축된 형태로 쓰여 있는 데도 말이다. 어떤 특성을 얼마나 자세히 설명할 것인지 정해야만 했다. 여기서도 C++ 커뮤니티의 많은 사람들이 도와줘 결정을 내릴 수 있었다. 일반적인 애플리케이션 프로그래머가 필요한 부분에 집중하자는 것이 목적이었다. 생략된 몇몇 부분에 대해서는 이 책의 웹사이트인 http://www.cppstdlib.com에 보조 장을 제공했으며, 표준에는 있지만 이 책에는 없는 세부사항도 찾을 수 있다.

뭔가를 가르치기 위해 모든 걸 나열해야 하는 건 아닐 것이다. 낱알만 잘 분리해서 잘 소화시킬 수 있게 해야 한다. 내 시도가 성공했길 바란다.

[제1판 서문]
처음에는 C++ 표준 라이브러리에 대한 (400쪽 정도 분량의) 짧은 독일어 책을 쓸 생각이었다. 그때가 1993년이었다. 이제 1999년에 그 결과가 나왔다. 영어 책인데도 설명과 그림, 그리고 예제들 때문에 800쪽이 넘는다. 내 목표는 C++ 표준 라이브러리를 설명해 모든(혹은 거의 모든) 프로그래밍에 관한 궁금증을 사전에 해소하는 것이었다. 하지만 이 책은 C++ 표준 라이브러리의 모든 측면을 설명하는 책은 아니라는 걸 알아줬으면 한다. 그보다는 표준 라이브러리를 사용해 C++을 배우고 프로그래밍하기 위해 좀 더 중요한 주제들을 설명하려 했다.

각 주제는 일반적인 개념에 대해 설명했다. 먼저 전반적인 사항에 대해 논의하고, 그후 매일매일의 프로그래밍에 필요한 세부사항을 덧붙였다. 개념과 세부사항을 이해할 수 있도록 예제도 제공했다.

간단히 말해 이게 끝이다. 여러분도 내가 누렸던 즐거움을 같이 느끼길 바란다. 즐겨라!

★ 옮긴이의 말 ★

박사 과정 시절 모니터 한 대에 비주얼 스튜디오를 띄워놓고, 자동완성을 즐기며 혼자서 프로그램을 만들 때에는, 그 프로그램을 혼자 이해하고 혼자 사용해도 충분했다. 잠시 쉬고 돌아왔을 때 그 코드를 이해할 수만 있다면 주석을 달 이유도, 가독성이 높을 필요도, 이식성이 높을 이유도 없었다.

사실 혼자서 프로그램을 만든다고 하면 표준 라이브러리보다는 자신만의 맞춤 라이브러리를 쓰는 게 더 나을 수도 있다. 훨씬 가볍고, 자신의 상황에 적합하며, 빠를 테니까 말이다. 하지만 진짜 상업용 프로그램을 만든다면 남들이 만들어 놓은 이해할 수 없는 함수 이름(코딩을 좀 해본 사람들이 가장 어려워하는 건 변수와 함수 이름 짓는 일이다), 복잡한 내부 구조, 숨어있는 내부 가정들… 그런 난관을 뚫고 나만이 이해할 수 있는 내 코드를 심어놓고 싶진 않을 것이다. 제대로 된 프로그램을 만들려면 기존 코드들도, 새 코드도 자신이나 자신을 사용하는 쪽에서 만들어낼 버그가 최대한 적어지도록, 그리고 유지/관리하기 쉽도록 표준화된 무언가를 공유하는 것이 좋을 것이다.

사실 자신만의 프로그램을 만든다 하더라도 문자열 처리/검색이나(C++의 문자열 처리는 정말이지 악명이 높다), 정렬 알고리즘같이 자주 쓰는 알고리즘을 써야 한다면, 처음부터 다시 만들어 쓰는 건 너무나 비효율적일 것이다. 왜냐면 내가 원하는 기능을 누가 이미 다 구현해놓았기 때문이다. 그게 바로 이 책에서 소개하고 있는 표준 라이브러리다. 표준 라이브러리는 많은 사람들이 C++ 프로그램을 작성하면서 필요했던 다양한 요구사항을 충족시키기 위해