Top

C++ 표준 라이브러리 제2판

  • 원서명The C++ Standard Library: A Tutorial and Reference (2nd Edition) (ISBN 9780321623218)
  • 지은이니콜라이 조슈티스
  • 옮긴이한정애
  • ISBN : 9788960774636
  • 50,000원
  • 2013년 08월 30일 펴냄
  • 페이퍼백 | 1,152쪽 | 188*250mm
  • 시리즈 : 프로그래밍 언어

책 소개

더욱 사용하기 편해지고 기능도 더 많아진 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++ 표준 라이브러리내의 여러 가지 메모리 모델에 대한 개념을 설명한다.

저자/역자 소개

[ 저자 서문 ]

나는 첫 판이 그렇게나 오랫동안 팔릴 줄은 생각도 못했었다. 하지만, 이제 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++을 배우고 프로그래밍하기 위해 좀 더 중요한 주제들을 설명하려 했다.

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

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


니콜라이 조슈티스 (Nicolai Josuttis)

통신, 교통과 제조 기업을 위한 중급부터 대규모까지의 소프트웨어 시스템을 디자인하는 독립 기술 컨설턴트다. C++ 표준 위원회 라이브러리 그룹의 멤버였으며, 권위 있는 책들로 프로그래밍 사회에서 유명하다. 1999년에 출간되어 전 세계적으로 베스트셀러가 된 『C++ 표준 라이브러리(초판)』 외에도, 『C++ 템플릿 가이드』(에이콘출판, 2008)와 『SOA in practice: The art of Distributed System Design』(O'Reilly Media, 2007)을 썼다.


[ 옮긴이의 말 ]

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

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

사실 자신만의 프로그램을 만든다 하더라도 문자열 처리/검색이나(C++의 문자열 처리는 정말이지 악명이 높다), 정렬 알고리즘같이 자주 쓰는 알고리즘을 써야 한다면, 처음부터 다시 만들어 쓰는 건 너무나 비효율적일 것이다. 왜냐면 내가 원하는 기능을 누가 이미 다 구현해놓았기 때문이다. 그게 바로 이 책에서 소개하고 있는 표준 라이브러리다. 표준 라이브러리는 많은 사람들이 C++ 프로그램을 작성하면서 필요했던 다양한 요구사항을 충족시키기 위해 필요한 몇 가지 공통 부분을 뽑아 제공한다. 그러니 이미 검증된 표준 구현을 가지고 내가 필요한 기능을 만들어 나간다면 만들기도 쉽고, 만들어내는 코드 양도 적고, 그에 따라 버그도 적다. 뿐만 아니다. 사실 이게 제일 중요한데, 시간이 지난 후에 내가 혹은 남들이 그 코드를 볼 때 쉽게 이해할 수 있다. 그래야 내가 휴가를 가더라도 남은 사람들이 내 버그를 고쳐줄 수 있을 테니까. 괜히 소중한 휴가 기간에 회사에서 전화 오는 걸 즐기지 말자. 그게 당신이 회사에 꼭 필요한 인물이라는 건 아니니까 말이다.

소프트웨어 개발자는 자신이 그날 하루 만들어 낼 수 있는 코드 양에 따라 초급/중급/고급이 나뉘는 게 아니다. 사실 한 개발자가 수천 줄의 코드로 구현한 기능을 다른 개발자는 몇 줄 만에 다 구현할 수도 있을 것이다. 이미 만들어진 코드 중 어떤 것을 어떻게 가져다 써야 하는지 잘 알기만 한다면 어려울 게 없다. 자, 이제 여러분도 손목 터널 증후군에서 벗어나기 위해서라도 이 책을 꼼꼼히 읽어보고 그동안 만들어온 프로그램을 곰곰이 되씹어 보자. 이 책 덕분에 앞으로 새로 개발할 때는 훨씬 단순하면서도 기능은 충실한 코드를 만들 수 있을 것 같다면 내게도 기쁜 일이겠다.

[ 옮긴이 소개 ]

한정애

서울대학교 컴퓨터공학과를 졸업하고 동 대학원에서 무선 통신에 대한 연구로 박사학위를 받았다. 현재 글로벌 소프트웨어 회사인 SAP에 속한 SAP Labs Korea에서 개발자로 일하고 있다. 리눅스와 리눅스 프로그램 등을 포함한 컴퓨터와 관련된 다양한 분야에 관심이 많다. 역서로 에이콘출판사에서 출간한 『리눅스 기반의 임베디드 제품 디자인』(2007), 『C++ 템플릿 가이드』(2008) 및 『두렵지 않은 C++』(2013)이 있다.

목차

목차
  • 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 헤더 파일 <cstddef>, <cstdlib>과 <cstring>
      • 5.8.1 <cstddef>내 정의
      • 5.8.2 <cstdlib> 내 정의
      • 5.8.3 <cstring> 내 정의
  • 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<bool>
    • 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 사용자 정의 할당자

도서 오류 신고

도서 오류 신고

에이콘출판사에 관심을 가져 주셔서 고맙습니다. 도서의 오탈자 정보를 알려주시면 다음 개정판 인쇄 시 반영하겠습니다.

오탈자 정보는 다음과 같이 입력해 주시면 됩니다.

(예시) p.100 아래에서 3행 : '몇일'동안 -> 며칠동안

정오표

정오표

[p.51: 아래에서 12행]

[p.51: 아래에서 10~11행]

[p.55: 아래에서 4행~5행]
lvalues일 경우 -> lvalue일 경우
rvalues일 경우 -> rvalue일 경우

[p.55: 아래에서 9행]
이제 모듬
->
이제 모음

[p.57: 아래에서 11행]
foo()는 lvalue와 value 모두에 대해 호출될 수 있다.
->
foo()는 lvalue와 rvalue 모두에 대해 호출될 수 있다.

[p.58: 4행]
value에 대해서만
->
rvalue에 대해서만

[p.61: 12행]
명세 자제를 생략
->
명세 자체를 생략

[p.101: 표 4행 첫 열]

[p.184: 13행(쉼표 삭제)]
!=, >, 등을
->
!=, > 등을

[p.279: 13행]
not found
->
못 찾음

[p.597: 9행]
subrange
->
하위 범위

[p.739: 7행~12행]

[p.793: 2행]

[p.878: 17행~18행]
값: 77 4d 출력
->
value: 77 4d 출력

값: 출력
->
value: 출력

[ p.887: 아래에서 5~6행]
output
->
출력

input
->
입력

[p.1045: 14행]
async() }
->
}

[p.1077: 아래에서 7행]
잠그고 자동으로 잠근 해지한다
->
잠그고 자동으로 잠금 해지한다

[p.1078: 20행]
잠그고 자동으로 잠근 해지한다
->
잠그고 자동으로 잠금 해지한다