Exploring_C++_The_Programmers_Introduction_to

About Global Documents

Global Documents provides you with documents from around the globe on a variety of topics for your enjoyment.
Global Documents utilizes edocr for all its document needs due to edocr's wonderful content features. Thousands of professionals and businesses around the globe publish marketing, sales, operations, customer service and financial documents making it easier for prospects and customers to find content.
Exploring Program book Compile pda Tool Function Standard write
Ray Lischner
Exploring C++
The Programmer’s Introduction 
to C++
Exploring C++: The Programmer’s Introduction to C++
Copyright © 2009 by Ray Lischner
All rights reserved. No part of this work may be reproduced or transmitted in any form or by any means, 
electronic or mechanical, including photocopying, recording, or by any information storage or retrieval 
system, without the prior written permission of the copyright owner and the publisher.
ISBN-13 (pbk): 978-1-59059-749-1
ISBN-10 (pbk): 1-59059-749-4
ISBN-13 (electronic): 978-1-4302-1895-1
Printed and bound in the United States of America 9 8 7 6 5 4 3 2 1
Trademarked names may appear in this book. Rather than use a trademark symbol with every occurrence 
of a trademarked name, we use the names only in an editorial fashion and to the benefit of the trademark 
owner, with no intention of infringement of the trademark.
Lead Editor: Matthew Moodie
Technical Reviewer: Francis Glassborow
Editorial Board: Clay Andres, Steve Anglin, Mark Beckner, Ewan Buckingham, Tony Campbell,  
Gary Cornell, Jonathan Gennick, Michelle Lowman, Matthew Moodie, Jeffrey Pepper,  
Frank Pohlmann, Ben Renow-Clarke, Dominic Shakeshaft, Matt Wade, Tom Welsh
Project Manager: Richard Dal Porto
Copy Editor: Octal Publishing, Inc.
Associate Production Director: Kari Brooks-Copony
Production Editor: Ellie Fountain
Compositor: Dina Quan
Proofreaders: Lisa Hamilton and Linda Seifert
Indexer: John Collin
Cover Designer: Kurt Krames
Manufacturing Director: Tom Debolski
Distributed to the book trade worldwide by Springer-Verlag New York, Inc., 233 Spring Street, 6th Floor, 
New York, NY 10013. Phone 1-800-SPRINGER, fax 201-348-4505, e-mail kn`ano)ju<olnejcan)o^i*_ki, or 
visit dppl6++sss*olnejcankjheja*_ki.
For information on translations, please contact Apress directly at 2855 Telegraph Avenue, Suite 600, 
Berkeley, CA 94705. Phone 510-549-5930, fax 510-549-5939, e-mail ejbk<]lnaoo*_ki, or visit  
dppl6++sss*]lnaoo*_ki.
Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use. 
eBook versions and licenses are also available for most titles. For more information, reference our Special 
Bulk Sales–eBook Licensing web page at dppl6++sss*]lnaoo*_ki+ejbk+^qhgo]hao.
The information in this book is distributed on an “as is” basis, without warranty. Although every precau-
tion has been taken in the preparation of this work, neither the author nor Apress shall have any liability 
to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indi-
rectly by the information contained in this work. 
The source code for this book is available to readers at dppl6++sss*]lnaoo*_ki. You may need to answer 
questions pertaining to this book in order to successfully download the code.
iii
Contents at a Glance
About the Author. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi
About the Technical Reviewer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiii
Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxv
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xxvii
PART 1 N N N The Basics
EXPLORATION 1 Honing Your Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
EXPLORATION 2 Reading C++ Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
EXPLORATION 3
Integer Expressions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
EXPLORATION 4 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
EXPLORATION 5 Simple Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
EXPLORATION 6
Error Messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
EXPLORATION 7
For Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
EXPLORATION 8
Formatted Output. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
EXPLORATION 9 Arrays and Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
EXPLORATION 10
Increment and Decrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
EXPLORATION 11 Conditions and Logic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
EXPLORATION 12 Compound Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
EXPLORATION 13
Introduction to File I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
EXPLORATION 14 The Map Data Structure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
EXPLORATION 15 Type Synonyms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
EXPLORATION 16 Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
EXPLORATION 17 Character Categories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
EXPLORATION 18 Case-Folding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
EXPLORATION 19 Writing Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
EXPLORATION 20 Function Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
NCONTENTS AT A GLANCE
iv
EXPLORATION 21 Using Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
EXPLORATION 22 Overloading Function Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
EXPLORATION 23 Big and Little Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
EXPLORATION 24 Very Big and Very Little Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
EXPLORATION 25 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
EXPLORATION 26 Project 1: Body-Mass Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
PART 2 N N N Custom Types
EXPLORATION 27 Custom Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
EXPLORATION 28 Overloading Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
EXPLORATION 29 Custom I/O Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
EXPLORATION 30 Assignment and Initialization. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
EXPLORATION 31 Writing Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
EXPLORATION 32 More About Member Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
EXPLORATION 33 Access Levels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
EXPLORATION 34
Introduction to Object-Oriented Programming . . . . . . . . . . . . . . . . 257
EXPLORATION 35
Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
EXPLORATION 36 Virtual Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
EXPLORATION 37 Classes and Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
EXPLORATION 38 Declarations and Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
EXPLORATION 39 Using Multiple Source Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
EXPLORATION 40 Function Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
EXPLORATION 41 Useful Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
EXPLORATION 42
Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
EXPLORATION 43 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
EXPLORATION 44 More Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
EXPLORATION 45 Project 2: Fixed-Point Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
PART 3 N N N Generic Programming
EXPLORATION 46 Function Templates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
EXPLORATION 47 Class Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
EXPLORATION 48 Template Specialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
NCONTENTS AT A GLANCE
v
EXPLORATION 49 Partial Specialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
EXPLORATION 50 Names and Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
EXPLORATION 51 Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
EXPLORATION 52
International Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
EXPLORATION 53 Locales and Facets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
EXPLORATION 54 Text I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
EXPLORATION 55 Project 3: Currency Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
PART 4 N N N Real Programming
EXPLORATION 56 Pointers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
EXPLORATION 57 Dynamic Memory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
EXPLORATION 58 Exception-Safety . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
EXPLORATION 59 Old-Fashioned Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
EXPLORATION 60 Smart Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
EXPLORATION 61 Working with Bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
EXPLORATION 62 Enumerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
EXPLORATION 63 Multiple Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
EXPLORATION 64 Traits and Policies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
EXPLORATION 65 Names and Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
EXPLORATION 66 Overloaded Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
EXPLORATION 67 Metaprogramming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
EXPLORATION 68 Project 4: Calculator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
INDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
vii
Contents
About the Author. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi
About the Technical Reviewer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxiii
Acknowledgments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxv
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xxvii
PART 1 N N N The Basics
EXPLORATION 1 Honing Your Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Ray’s Recommendations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Microsoft Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
Macintosh OS 9 and Earlier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Everyone Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Read the Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Your First Program. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
EXPLORATION 2 Reading C++ Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Comments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Headers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Main Program. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
Variable Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
EXPLORATION 3
Integer Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
EXPLORATION 4 Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
EXPLORATION 5 Simple Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
NCONTENTS
viii
EXPLORATION 6 Error Messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Misspelling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Bogus Character . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Unknown Operator. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Unknown Name . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Symbol Errors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Fun with Errors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
EXPLORATION 7 For Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Bounded Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
Condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Postiteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
How a for Loop Works. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Your Turn. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
EXPLORATION 8 Formatted Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
The Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Field Width . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Padding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
std Prefix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Alignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Exploring Formatting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Alternative Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
On Your Own. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
EXPLORATION 9 Arrays and Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
Using Vectors for Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Vectors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
Member Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Using Iterators and Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
EXPLORATION 10 Increment and Decrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Increment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Decrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
NCONTENTS
ix
EXPLORATION 11 Conditions and Logic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
I/O and bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Boolean Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
Logic Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Old-Fashioned Syntax. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Comparison Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
EXPLORATION 12 Compound Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Local Definitions and Scope. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Definitions in for Loop Headers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
EXPLORATION 13 Introduction to File I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Reading Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Writing Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
EXPLORATION 14 The Map Data Structure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Using Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
Searching in Maps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
EXPLORATION 15 Type Synonyms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
typedef Declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
Common typedefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
EXPLORATION 16 Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Character Type. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
Character I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Newlines and Portability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
Character Escapes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
EXPLORATION 17 Character Categories. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Character Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
Character Categories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
NCONTENTS
x
EXPLORATION 18 Case-Folding. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Simple Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
Harder Cases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
EXPLORATION 19 Writing Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Function Call. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Declarations and Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
Counting Words, Again . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
The main() Function. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
EXPLORATION 20 Function Arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Argument Passing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Pass-by-Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
const References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
const_iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
Output Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
EXPLORATION 21 Using Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Transforming Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Predicates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Other Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
EXPLORATION 22 Overloading Function Names . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Overloading. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
EXPLORATION 23 Big and Little Numbers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
The Long and Short of It . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
Long Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Short Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
Integer Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Byte-Sized Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Type Casting. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Integer Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
Overload Resolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
NCONTENTS
xi
EXPLORATION 24 Very Big and Very Little Numbers . . . . . . . . . . . . . . . . . . . . . . 173
Floating-Point Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Floating-Point Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Floating-Point Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Floating-Point I/O. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
EXPLORATION 25 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Doxygen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Structured Comments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Documentation Tags . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
Using Doxygen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
EXPLORATION 26 Project 1: Body-Mass Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
Hints. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
PART 2 N N N Custom Types
EXPLORATION 27 Custom Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Defining a New Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Member Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
Overloading Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
EXPLORATION 28 Overloading Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Comparing Rational Numbers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
Arithmetic Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
Math Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
EXPLORATION 29 Custom I/O Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Input Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
Output Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
Error State. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
NCONTENTS
xii
EXPLORATION 30 Assignment and Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Assignment Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Putting It All Together . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
EXPLORATION 31 Writing Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Anatomy of a Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Member Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
Constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230
EXPLORATION 32 More About Member Functions . . . . . . . . . . . . . . . . . . . . . . . . . 235
Invoking the Default Constructor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Revisiting Project 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
const Member Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
EXPLORATION 33 Access Levels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
Public vs. Private . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
class vs. struct . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
Plain Old Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Public or Private?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
EXPLORATION 34 Introduction to  Object- Oriented Programming . . . . . . . . 257
Books and Magazines. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257
Classification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258
Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
Liskov’s Substitution Principle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Type Polymorphism. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263
EXPLORATION 35 Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Deriving a Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
Destructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Access Level. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
Programming Style . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
NCONTENTS
xiii
EXPLORATION 36 Virtual Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Type Polymorphism. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
Virtual Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
References and Slices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
Pure Virtual Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
Virtual Destructors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
EXPLORATION 37 Classes and Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Classes vs. typedefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
Value Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Copying . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286
Assigning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
Comparing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
Resource Acquisition Is Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
EXPLORATION 38 Declarations and Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Declaration vs. Definition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Inline Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Variable Declarations and Definitions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
Static Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299
Static Data Members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
Declarators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
EXPLORATION 39 Using Multiple Source Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Multiple Source Files. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Declarations and Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
#include Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Quotes and Brackets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
Nested #include Directives. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
Include Guards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
extern Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Inline Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
One-Definition Rule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
NCONTENTS
xiv
EXPLORATION 40 Function Objects. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
The Function Call Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Function Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323
Recycling Member Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
Generator Functor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 328
EXPLORATION 41 Useful Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Searching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Linear Search Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Binary Search Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
Comparing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Rearranging Data. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
Copying Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Deleting Elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 344
EXPLORATION 42 Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Kinds of Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
Input Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
Output Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
Forward Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
Bidirectional Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
Random Access Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
Working with Iterators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348
const_iterator vs. const iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
Error Messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Specialized Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
The Importance of Being Iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
EXPLORATION 43 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Introducing Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
Catching Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
Throwing Exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
Program Stack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Standard Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
I/O Exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
Custom Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Exceptional Advice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
NCONTENTS
xv
EXPLORATION 44 More Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Conditional Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Short-Circuit Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
Comma Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
Arithmetic Assignment Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
Increment and Decrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
EXPLORATION 45 Project 2: Fixed-Point Numbers . . . . . . . . . . . . . . . . . . . . . . . . 385
PART 3 N N NGeneric Programming
EXPLORATION 46 Function Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Generic Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
Using Function Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
Writing Function Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Template Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
Template Arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399
Declarations and Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
Member Function Templates. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 402
EXPLORATION 47 Class Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Parameterizing a Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
Parameterizing the rational Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
Using Class Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
Overloaded Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Mixing Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
EXPLORATION 48 Template Specialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Instantiation and Specialization. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
Custom Comparators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
Specializing Function Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
NCONTENTS
xvi
EXPLORATION 49 Partial Specialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Degenerate Pairs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423
Partial Specialization. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
Partially Specializing Function Templates . . . . . . . . . . . . . . . . . . . . . . . . . . 425
Value Template Parameters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
EXPLORATION 50 Names and Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
Nested Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
Global Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
The std Namespace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
Using Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
The using Directive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
The using Declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
The using Declaration in a Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
Unnamed Namespaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
Name Lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
EXPLORATION 51 Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
Properties of Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
Technical Report 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
Member Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451
What Can Go Into a Container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
Inserting and Erasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Inserting in a Sequence Container . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Erasing From a Sequence Container . . . . . . . . . . . . . . . . . . . . . . . . . 454
Inserting in an Associative Container . . . . . . . . . . . . . . . . . . . . . . . . . 455
Erasing From an Associative Container . . . . . . . . . . . . . . . . . . . . . . . 457
Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457
Iterators and References . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458
Sequence Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
The array Class Template. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
The deque Class Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
The list Class Template. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
The vector Class Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
Associative Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
NCONTENTS
xvii
EXPLORATION 52 International Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Why Wide? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Using Wide Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
Wide Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
Wide Character I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Multi-Byte Character Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477
Universal Character Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479
EXPLORATION 53 Locales and Facets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
The Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
Locales to the Rescue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
Locales and I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
Facets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 483
Character Categories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Collation Order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492
EXPLORATION 54 Text I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
File Modes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
String Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496
Text Conversion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
Boost Lexical Cast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
EXPLORATION 55 Project 3: Currency Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509
PART 4 N N NReal Programming
EXPLORATION 56 Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
The Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
The Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Addresses vs. Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523
Dependency Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524
NCONTENTS
xviii
EXPLORATION 57 Dynamic Memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Allocating Memory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527
Freeing Memory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
Pointer to Nothing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528
Implementing Standard Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
Adding Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532
Special Member Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
EXPLORATION 58 Exception-Safety . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
Memory Leaks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545
Exceptions and Dynamic Memory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 547
Automatically Deleting Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
What You Can’t Do with auto_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
Exceptions and Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552
EXPLORATION 59 Old-Fashioned Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
C-Style Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557
Array Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558
Dynamically Allocating an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559
Multi-Dimensional Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
C-Style Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 561
Command-Line Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
Pointer Arithmetic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 564
EXPLORATION 60 Smart Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Revisiting auto_ptr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567
Copyable Smart Pointers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569
Smart Arrays. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571
Pimpls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572
Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580
EXPLORATION 61 Working with Bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
Integer As a Set of Bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581
Bit Masks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 583
Shifting Bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584
NCONTENTS
xix
Safe Shifting with Unsigned Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585
Signed and Unsigned Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586
Unsigned Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
Type Conversions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 587
Overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592
Introducing Bitfields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
Portability . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
The bitset Class Template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
EXPLORATION 62 Enumerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
Ideal Enumerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599
Enumerations As Bitmasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
Simulating Enumerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602
Enumerating Computer Languages . . . . . . . . . . . . . . . . . . . . . . . . . . 602
Comparing Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
Strings and Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605
Initializing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
Reading and Writing Languages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
Using the Simulated Enumeration. . . . . . . . . . . . . . . . . . . . . . . . . . . . 611
Revisiting Projects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
EXPLORATION 63 Multiple Inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
Multiple Base Classes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
Virtual Base Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
Java-Like Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
Interfaces vs. Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
Mix-Ins. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624
Friends to the Rescue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 625
Protected Access Level . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 627
EXPLORATION 64 Traits and Policies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
Case Study: Iterators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
Iterator Traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634
Case Study: char_traits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635
Policy-Based Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
NCONTENTS
xx
EXPLORATION 65 Names and Templates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
Problems with Qualified Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 645
Problems with Unqualified Names . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
EXPLORATION 66 Overloaded Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
Review of Overloaded Functions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
Overload Resolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658
Candidate Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
Viable Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 660
Best Viable Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
Default Arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665
EXPLORATION 67 Metaprogramming. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
Compile-Time Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
Template Specialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669
Partial Specialization. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671
EXPLORATION 68 Project 4: Calculator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679
INDEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681
xxi
About the Author
NRAY LISCHNER is the author of C++ in a Nutshell and other books. He has been programming 
for over three decades, using languages as diverse as Algol, APL, Bash, C, C++, COBOL, csh, 
DCL, Delphi, Eiffel, Fortran, Haskell, Icon, Java, LISP, Pascal, Perl, PHP, PL/I, Python, Ruby, 
Scheme, Smalltalk, and a variety of assemblers.
In the years after he graduated from Caltech (in the mid-1980s), Ray worked as a software 
developer on both coasts of the United States, with stops in between. He has worked at com-
panies big and small: from start-ups to Fortune 500. Not so very long ago, he decided to escape 
from the corporate rat race. Due to a minor error in timing, he quit before he figured out how 
to pay for such trivialities as food and shelter. Undaunted, he persevered and soon discovered 
writing as a means to keep the creditors at bay.
Ray has always enjoyed teaching. While his wife completed her Ph.D. in physics, he occu-
pied his time teaching computer science at Oregon State University. Dissatisfied with the 
traditional introductory computer science curriculum, he revamped the first programming 
course and introduced novel lecture and teaching techniques. He pioneered interactive teach-
ing labs—the genesis of this book.
Today, Ray lives in Maryland with his wife and two children. Ray has returned to full-time 
work as a software developer at Proteus Technologies, where he is the resident C++ expert. 
Writing has become a part-time endeavor. When he isn’t working, Ray has a variety of other 
part-time, unpaid jobs: chef, taxi driver, house cleaner, arbitrator, soccer coach, banker, tooth 
fairy, story reader, and chief enforcer of the domestic nocturnal preparation procedure, just to 
name a few.
The best way to contact Ray is via email to atlhknejc<_lldahl*_ki.
xxiii
About the Technical Reviewer
NFRANCIS GLASSBOROW read Mathematics at Merton College, Oxford. He spent 25 years teach-
ing mathematics and computing studies to teenagers. Ill health forced him to retire from 
teaching. In 1989 he became editor of C Vu (ACCU’s principal journal) which job/office he 
held until 2002. He was chair of ACCU throughout the 1990s. He was a regular columnist for 
.EXE magazine (a UK developers magazine) from 1991 until it ceased publication in August 
2000. He was chair of the annual ACCU conference for seven years. He has been an active 
member of the BSI panels for C and C++ since 1991 and is a regular member of the BSI del-
egations to SC22/WG21 (ISO C++) and SC22/WG14 (ISO C) and is frequently HoD for these 
meetings. He is the author of You Can Do It!, an introduction for novice programmers, and 
You Can Program in C++, an introduction to C++ for those who can already program.
xxv
Acknowledgments
This book has been more difficult and time consuming than any of my previous books. I 
appreciate beyond words the patience of Apress and the staff who helped bring this project to 
fruition: particularly Matthew Moodie and Richard Dal Porto.
I am especially grateful to my Technical Reviewer, Francis Glassborow, whose deep 
knowledge of C++ has saved me from mistakes big and small. If any technical errors remain, 
no doubt I introduced them too late in the editing cycle for Francis to spot them.
Most of all, I thank my wife, Cheryl, whose support and encouragement sustained me 
when I lacked the strength to carry on. I also thank my children who put up with days and 
evenings without me while I finished this book. I love you all.
Finally, I thank the scientists and doctors who have worked miracles in the treatment of 
rheumatoid arthritis, permitting me to continue to work, write, and play.
xxvii
Introduction
Hi, there. Thank you for reading my book, Exploring C++. My name is Ray, and I’ll be your 
author today. And tomorrow. And the day after that. We’ll be together for quite a while, so why 
don’t you pull up a chair and get comfortable. My job is to help you learn C++. To do that, I 
have written a series of lessons, called explorations. Each exploration is an interactive exercise 
that helps you learn C++ one step at a time. Your job is to complete the explorations, and in so 
doing, learn C++.
No doubt you have already leafed through the book a little bit. If not, do so now. Notice 
that this book is different from most books. Most programming books are little more than 
written lectures. The author tells you stuff and expects you to read the stuff, learn it, and 
understand it.
This book is different. I don’t see much point in lecturing at you. That’s not how people 
learn best. You learn programming by reading, modifying, and writing programs. To that end, 
I’ve organized this book so that you spend as much time as possible reading, modifying, and 
writing programs.
How to Use This Book
Each exploration in this book is a mixture of text and interactive exercises. The exercises are 
unlike anything you’ve seen in other books. Instead of multiple choice, fill-in-the-blank, or 
simple Q&A exercises, my lessons are interactive explorations of key C++ features. Early in the 
book, I will give you complete programs to work with. As you learn more C++, you will modify 
and extend programs. Pretty soon, you will write entire programs on your own.
By “interactive,” I mean that I ask questions and you answer them. I do my best to 
respond to your answers throughout the lesson text. It sounds crazy, but by answering the 
questions, you will be learning C++. To help ensure you answer the questions, I leave space in 
this book for you to write your answers. I’m giving you permission to write in this book (unless 
you are borrowing the book from a library or friend). In fact, I encourage you to write all your 
answers in the book. Only by answering the questions will you learn the material properly.
Sometimes, the questions have no right answer. I pose the question to make you ponder 
it, perhaps to look at a familiar topic from a new perspective. Other times, the question has an 
unambiguous, correct answer. I always give the answer in the subsequent text, so don’t skip 
ahead! Write your answer before you continue reading. Then and only then can you check 
your answer. Some questions are tricky or require information that I have not yet presented. 
In such cases, I expect your answer to be wrong, but that’s okay. Don’t worry. I won’t be grad-
ing you. (If you are using this book as part of a formal class, your teacher should grade this 
book’s exercises solely on whether you complete them, and never on whether your answer 
was correct. The teacher will have other exercises, quizzes, and tests to assess your progress in 
NINTRODUCTION
xxviii
the class.) And no fair looking ahead and writing down the “correct” answer. You don’t learn 
anything that way.
Ready? Let’s practice.
What is your most important task when reading this book?
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
This question does not have a single correct answer, but it does have a number of demon-
strably wrong answers. I hope you wrote something similar to, “Completing every exercise” or 
“Understanding all the material.” Another good answer is, “Having fun.”
The Book’s Organization
C++ is a complicated language. To write even the most trivial program requires an under-
standing of many disparate aspects of the language. The language does not lend itself to neat 
compartmentalization into broad topics, such as functions, classes, statements, or expres-
sions. This book, therefore, does not attempt such an organization. Instead, you learn C++ in 
small increments: a little bit of this, a little bit of that, some more of this, and pretty soon you 
will have accumulated enough knowledge to start writing nontrivial programs.
Roughly speaking, the book starts with basic expressions, declarations, and statements 
that are sufficient to work with simple programs. You learn how to use the standard library 
early in the book. Next, you learn to write your own functions, to write your own classes, to 
write your own templates, and then to write fairly sophisticated programs.
You won’t be an expert, however, when you finish this book. You will need much more 
practice, more exposure to the breadth and depth of the language and library, and more prac-
tice. You will also need more practice. And some more. You get the idea.
Who Should Read This Book
Read this book if you want to learn C++ and you already know at least one other programming 
language. You don’t need to know a specific language or technology, however. In particu-
lar, you don’t need to know C, nor do you need to know anything about object-oriented 
programming.
The C programming language influenced the design of many other languages, from PHP 
to Perl to AWK to C#, not to mention C++. As a result, many programmers who do not know C 
or C++ nonetheless find many language constructs hauntingly familiar. You might even feel 
confident enough to skip sections of this book that seem to cover old ground. Don’t do that! 
From the start, the lessons present language features that are unique to C++. In a few, isolated 
cases, I will tell you when it is safe to skip a section, and only that section. Even when a lan-
guage feature is familiar, it might have subtle issues that are unique to C++.
The trap is most perilous for C programmers because C++ bears the greatest superficial 
similarity with C. C programmers, therefore, have the most to overcome. By design, many 
C programs are also valid C++ programs, leading the unwary C programmer into the trap of 
thinking that good C programs are also good C++ programs. In fact, C and C++ are distinct 
NINTRODUCTION
xxix
languages, each with their own idioms and idiosyncrasies. To become an effective C++ pro-
grammer, you must learn the C++ way of programming. C programmers need to break some of 
their established habits and learn to avoid certain C features (such as arrays) in favor of better 
C++ idioms. The structure of this book helps you get started thinking in terms of C++, not C.
Projects
This book also contains four projects. The projects are opportunities to apply what you have 
learned. Each project is a realistic endeavor, based on the amount of C++ covered up to that 
point. I encourage you to try every project. Design your project using your favorite software 
design techniques. Remember to write test cases in addition to the source code. Do your best 
to make the code clean and readable, in addition to correct. After you are confident that your 
solution is finished, download the files from the book’s web site, and compare your solution 
with mine.
Work Together
You can use this book alone, teaching yourself C++, or a teacher might adopt this book as a 
textbook for a formal course. You can also work with a partner. It’s more fun to work with 
friends, and you’ll learn more and faster by working together. Each of you needs your own 
copy of the book. Read the lessons and do the work on your own. If you have questions, dis-
cuss them with your partner, but answer the exercises on your own. Then compare answers 
with your partner. If your answers are different, discuss your reasoning. See if you can agree 
on a single answer before proceeding.
Work on the projects together. Maybe you can divide the work into two (or more) mod-
ules. Maybe one person codes and the other person checks. Maybe you’ll practice some form 
of pair programming. Do whatever works best for you, but make sure you understand every 
line of code in the project. If you have asymmetric roles, be sure to swap roles for each project. 
Give everyone a chance to do everything.
For More Information
This book cannot teach you everything you need to know about C++. No single book can. 
After you finish this book, I encourage you to continue to read and write C++ programs, and to 
seek out other sources of information. To help guide you, this book has a dedicated web site, 
dppl6++_lldahl*_ki+atlhknejc+. The web site has links to other books, other web sites, mail-
ing lists, newsgroups, FAQs, compilers, other tools, and more. You can also download all the 
source code for this book, so you can save yourself some typing.
Why Explorations?
In case you were wondering about the unusual nature of this book, rest assured that, “though 
this be madness, yet there is method in’t.”
The method is an approach to teaching and writing that I developed while I was teaching 
computer science at Oregon State University. I wanted to improve the quality of my teaching, 
NINTRODUCTION
xxx
so I investigated research into learning and knowledge, especially scientific knowledge, and in 
particular, computer programming.
To summarize several decades of research: everyone constructs mental models of the 
world. We acquire knowledge by adding information to our models. The new information 
must always be in concert with the model. Sometimes, however, new information contradicts 
the model. In that case, we must adjust our models to accommodate the new information. 
Our brains are always at work, always taking in new information, always adjusting our mental 
models to fit.
As a result of this research, the emphasis in the classroom has shifted from teachers to stu-
dents. In the past, teachers considered students to be empty vessels, waiting to be filled from 
the fount of the teacher’s knowledge and wisdom. Students were passive recipients of infor-
mation. Now we know better. Students are not passive, but active. Even when their outward 
appearance suggests otherwise, their brains are always at work, always absorbing new infor-
mation and fitting that information into their mental models. The teacher’s responsibility has 
changed from being the source of all wisdom to being an indirect manager of mental models. 
The teacher cannot manage those models directly, but can only create classroom situations in 
which students have the opportunity to adjust their own models.
Although the research has focused on teachers, the same applies to authors.
In other words, I cannot teach you C++, but I can create explorations that enable you to 
learn C++. Explorations are not the only way to apply research to learning and writing, but 
they are a technique that I have refined over several years of teaching and have found success-
ful. Explorations work because
s 4HEY FORCE YOU TO PARTICIPATE ACTIVELY IN THE LEARNING PROCESS )TS TOO EASY TO READ A
book passively. The questions force you to confront new ideas and to fit them into your 
mental model. If you skip the questions, you might also skip a crucial addition to your 
model.
s 4HEY ARE SMALL SO YOUR MODEL GROWS IN EASY STEPS )F YOU TRY TO GRASP TOO MUCH NEW
information at once, you are likely to incorporate incorrect information into your 
model. The longer that misinformation festers, the harder it will be to correct. I want 
to make sure your model is as accurate as possible at all times.
s 4HEY BUILD ON WHAT YOU KNOW ) DONT TOSS OUT NEW CONCEPTS WITH THE VAIN HOPE THAT
you will automatically grasp them. Instead, I tie new concepts to old ones. I do my best 
to ensure that every concept has a strong anchor in your existing mental model.
s 4HEY HELP YOU LEARN BY DOING )NSTEAD OF SPENDING THE BETTER PART OF A CHAPTER READ-
ing how someone else solves a problem, you spend as much time as possible working 
hands-on with a program: modifying existing programs and writing new programs.
C++ is a complicated language, and learning C++ is not easy. In any group of C++ pro- 
grammers, even simple questions can often provoke varied responses. Most C++ programmers’ 
mental models of the language are not merely incomplete, but are flawed, sometimes in fun-
damental ways. My hope is that I can provide you with a solid foundation in C++, so that you 
can write interesting and correct programs, and most importantly, so that you can continue to 
learn and enjoy C++ for many years to come.
NINTRODUCTION
xxxi
The C++ Standard
This book covers the current standard, namely, ISO/IEC 14882:2003 (E), Programming
languages — C++. The 2003 edition of the standard is a bug-fix edition, containing corrections 
to and clarifications of the original 1998 edition. Most modern compilers do a decent job of 
conforming to the standard.
The standardization committee has also issued an addendum to the standard, adding 
regular expressions, mathematical functions, and a lot more. This addendum is an optional 
extension to the standard library called Technical Report 1, or TR1. Because it is optional, ven-
dors are not required to implement it. Most vendors provide at least part of the library. A few 
implement TR1 in its entirety. You do not need TR1 support to use this book, but I point out a 
few cases where TR1 makes your life a little easier.
By issuing TR1 and having thousands of C++ developers use it, the standardization com-
mittee gained valuable practical experience to feed back into the next major revision of the 
C++ standard. Work on the next revision is underway as I write this. Depending on when you 
read this, their work may be complete. You may even have a compiler and library that con-
forms to the new release of the standard, which will likely be labeled ISO/IEC 14882:2010 (E).
Even if you have a brand new compiler, this book still has value. Many of the new features 
are advanced so they don’t affect this book. Other planned features impact C++ programmers 
of all levels and abilities. I point out the proposed changes throughout this book, but keep my 
focus on the tools that are available and in widespread use today.
P A R T  1
The Basics
3
E X P L O R A T I O N  1
Honing Your Tools
Before you begin your exploration of the C++ landscape, you need to gather some basic 
supplies: a text editor, a C++ compiler, a linker, and a debugger. You can acquire these tools 
separately or bundled, possibly as a package deal with an integrated development environ-
ment (IDE). Options abound regardless of your platform, operating system, and budget.
If you are taking a class, the teacher will provide the tools or dictate which tools to use. If 
you are working at an organization that already uses C++, you probably want to use their tools, 
so you can become familiar with them and their proper use. If you need to acquire your own 
tools, check out this book’s web site, dppl6++_lldahl*_ki+atlhknejc+. Tool versions and qual-
ity change too rapidly to provide details in print form, so you can find up-to-date suggestions 
on the web site. The following section gives some general advice.
Ray’s Recommendations
C++ is one of the most widely used programming languages in the world: it is second only to C 
(depending on how you measure “widely used”). Therefore, C++ tools abound for many hard-
ware and software environments and at a wide variety of price points.
You can choose command-line tools, which are especially popular in UNIX and UNIX-like 
environments, or you can opt for an IDE, which bundles all the tools into a single graphical 
user interface (GUI). Choose whichever style you find most comfortable. Your programs won’t 
care what tools you use to edit, compile, and link them.
Microsoft Windows
If you are working with Microsoft Windows, I recommend Microsoft’s Visual Studio (be sure 
that you have a current release). In particular, the venerable Visual C++ 6.0 is obsolete and out-
of-date. As I write this, the current release is Visual Studio 2008. If you want a no-cost option, 
download Visual C++ Express from Microsoft’s web site (find a current link at dppl6++_lldahl*
_ki), or for an open source solution, download MinGW, which is a port of the popular GNU 
compiler to Windows.
Note that C++/CLI is not the same as C++. It is a new language that Microsoft invented to 
help integrate C++ into the .NET environment. That’s why it chose a name that incorporates 
C++, just as the name C++ derives from the name C. It is, however, a distinct language from C. 
This book covers standard C++ and nothing else. If you decide to use Visual Studio, take care 
that you work with C++, not C++/CLI or Managed C++ (the predecessor to C++/CLI).
EXPLORATION 1 N  HONING YOUR TOOLS
4
Visual Studio includes a number of doodads, froufrous, and whatnots that are unimport-
ant for your core task of learning C++. Perhaps you will need to use ATL, MFC, or .NET for your 
job, but for now, you can ignore all that. All you need is the C++ compiler and standard library.
If you prefer a free (as in speech) solution, the GNU compiler collection is available on 
Windows. Choose the Cygwin distribution, which includes a nearly complete UNIX-like envi-
ronment, or MinGW, which is much smaller and might be easier to manage. In both cases, 
you get a good C++ compiler and library. This book’s web site has links with helpful hints on 
installing and using these tools.
Macintosh OS 9 and Earlier
If you are stuck using an old Macintosh, download the no-cost Macintosh Programmer’s 
Workbench from Apple’s web site (link at dppl6++_lldahl*_ki).
Everyone Else
I recommend the GNU compiler collection (GCC). The C++ compiler is called g++. Linux and 
BSD distributions typically come with GCC, but you might need to install the necessary devel-
oper packages. Be sure you have a recent release (version 3.4 or later) of GCC.
Mac OS X also uses GCC. For a no-cost IDE, download Xcode from Apple’s web site (link 
at dppl6++_lldahl*_ki).
Some hardware vendors (Sun, HP, etc.) offer a commercial compiler specifically for their 
hardware. This compiler might offer better optimization than GCC, but might not conform to 
the C++ standard as well as GCC. At least while you work through the exercises in this book, I 
recommend GCC. If you already have the vendor’s compiler installed and you don’t want to 
bother installing yet another compiler, go ahead and use the vendor’s compiler. However, if it 
ever trips over an example in this book, be prepared to install GCC.
If you are using an Intel hardware platform, Intel’s compiler is excellent and available at 
no cost for noncommercial use. Visit the book’s web site for a current link.
If you want to use an IDE, choose from Eclipse, KDevelop, Anjuta, and others (go to 
dppl6++_lldahl*_ki for an up-to-date list).
Read the Documentation
Now that you have your tools, take some time to read the product documentation—especially 
the Getting Started section. Really, I mean it. Look for tutorials and other quick introductions 
that will help you get up to speed with your tools. If you are using an IDE, you especially need 
to know how to create simple command-line projects.
IDEs typically require you to create a project, workspace, or some other envelope, or 
wrapper, before you can actually write a C++ program. You need to know how to do this, and I 
can’t help you because every IDE is different. If you have a choice of project templates, choose 
“console,” “command-line,” “terminal,” “C++ Tool,” or some project with a similar name.
How long did it take you to read the documentation for your compiler and other tools? 
________________
Was that too much time, too little time, or just right? ________________
EXPLORATION 1 N  HONING YOUR TOOLS
5
The C++ language is subject to an international standard. Every compiler (more or less) 
adheres to that standard, but also throws in some nonstandard extras. These extras can be 
useful—even necessary—for certain projects, but for this book, you need to make sure you use 
only standard C++. Most compilers can turn off their extensions. Even if you didn’t read the 
documentation before, do so now to find out which options you need to enable to compile 
standard C++ and only standard C++.
Write down the options, for future reference.
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
You may have missed some of the options; they can be obscure. To help you, Table 1-1 
lists the command-line compiler options you need for Microsoft Visual C++ and for g++. This 
book’s web site has suggestions for some other popular compilers. If you are using an IDE, 
look through the project options or properties to find the equivalents.
Table 1-1. Compiler Options for Standard C++
Compiler
Options
Visual C++ command line
+ADo_ +V]
Visual C++ IDE
Enable C++ exceptions, disable language extensions
g++
)la`]jpe_ )]joe
Your First Program
Now that you have your tools, it’s time to start. Fire up your favorite text editor or your C++ 
IDE and start your first project or create a new file. Name this file heop,-,-*_ll, which is short 
for Listing 1-1. Several different file name extensions are popular for C++ programs. I like to 
use *_ll, where the “p” means “plus.” Other common extensions are *_tt and *__. Some 
compilers recognize *? (uppercase C) as a C++ file extension, but I don’t recommend using it 
because it is too easy to confuse with *_ (lowercase c), the default extension for C programs. 
Many desktop environments do not distinguish between uppercase and lowercase file names, 
further compounding the problem. Pick your favorite and stick with it. Type in the text con-
tained within Listing 1-1. (With one exception, you can download all the code listings from this 
book’s web site. Listing 1-1 is that exception. I want you to get used to typing C++ code in your 
text editor.)
Listing 1-1. Your First C++ Program
+++ Oknp pda op]j`]n` ejlqp ]hld]^ape_]hhu*
+++ Na]` hejao kb patp( oknp pdai( ]j` lnejp pda naoqhpo pk pda op]j`]n` kqplqp*
+++ Eb pda _kii]j` heja j]iao ] beha( na]` bnki pd]p beha* Kpdanseoa( na]` bnki
+++ pda op]j`]n` ejlqp* Pda ajpena ejlqp eo opkna` ej iaiknu( ok `kjÑp pnu
+++ pdeo sepd ejlqp behao pd]p at_aa` ]r]eh]^ha N=I*
EXPLORATION 1 N  HONING YOUR TOOLS
6
ej_hq`a 8]hcknepdi:
ej_hq`a 8bopna]i:
ej_hq`a 8ekopna]i:
ej_hq`a 8epan]pkn:
ej_hq`a 8kopna]i:
ej_hq`a 8opnejc:
ej_hq`a 8ra_pkn:
rke` na]`$op`66eopna]i" ej( op`66ra_pkn8op`66opnejc:" patp%
w
op`66opnejc heja7
sdeha $op`66capheja$ej( heja%%
patp*lqod[^]_g$heja%7
y
ejp i]ej$ejp ]nc_( _d]n& ]ncrWY%
w
++ L]np -* Na]` pda ajpena ejlqp ejpk patp* Eb pda _kii]j` heja j]iao ] beha(
++ na]` pd]p beha* Kpdanseoa( na]` pda op]j`]n` ejlqp*
op`66ra_pkn8op`66opnejc: patp7 +++8 Opkna pda hejao kb patp dana
eb $]nc_ 8 .%
na]`$op`66_ej( patp%7
ahoa
w
op`66ebopna]i ej$]ncrW-Y%7
eb $jkp ej%
w
op`66lannkn$]ncrW-Y%7
napqnj ATEP[B=EHQNA7
y
na]`$ej( patp%7
y
++ L]np .* Oknp pda patp*
op`66oknp$patp*^acej$%( patp*aj`$%%7
++ L]np /* Lnejp pda oknpa` patp*
op`66_klu$patp*^acej$%( patp*aj`$%(
op`66kopna]i[epan]pkn8op`66opnejc:$op`66_kqp( Xj%%7
y
No doubt, some of this code is gibberish to you. That’s okay. The point of this exercise 
is not to understand C++, but to make sure you can use your tools properly. The comments 
describe the program, which is a simple sort utility. I could have started with a trivial, “Hello, 
world” type of program, but that touches only a tiny fraction of the language and library. This 
program, being slightly more complex, does a better job at revealing possible installation or 
other problems with your tools.
EXPLORATION 1 N  HONING YOUR TOOLS
7
Now go back and double-check your source code. Make sure you entered everything cor-
rectly.
Did you actually double-check the program? ________________
Did you find any typos that needed correcting? ________________
To err is human, and there is no shame in typographical errors. We all make them. Go 
back and recheck your program.
Now compile your program. If you are using an IDE, find the Compile or Build button or 
menu item. If you are using command-line tools, be sure to link the program, too. For histori-
cal (or hysterical) reasons, UNIX tools such as g++ typically produce an executable program 
named ]*kqp. You should rename it to something more useful, or use the )k option to name an 
output file. Table 1-2 shows sample command lines to use for Visual C++ and g++.
Table 1-2. Sample Command Lines to Compiler heop,-,-*_ll
Compiler
Command Line
Visual C++
_h +ADo_ +V] heop,-,-*_ll
g++
c'' )k heop,-,- )la`]jpe_ )]joe heop,-,-*_ll
If you get any errors from the compiler, it means you made a mistake entering the source 
code; the compiler, linker, or C++ library has not been installed correctly; or the compiler, 
linker, or library does not conform to the C++ standard and so are unsuitable for use with this 
book. Triple-check you entered the text correctly. If you are confident that the error lies with 
the tools and not with you, check the date of publication. If the tools predate 1998, discard 
them immediately. They predate the standard and therefore, by definition, they cannot con-
form to the standard. In fact, the quality of C++ tools has improved tremendously in the last 
few years; so much so that I recommend discarding any tools that predate 2005. If the tools are 
recent, you might try the old trick of reinstalling them.
If all else fails, try a different set of tools. Download the current release of GCC or Visual 
Studio Express. You may need to use these tools for this book, even if you must revert to some 
crusty, rusty, old tools for your job.
Successful compilation is one thing, but successful execution is another. How you invoke 
the program depends on the operating system. In a GUI environment, you will need a console 
or terminal window where you can type a command line. You may need to type the complete 
path to the executable file, or just the program name—again, this depends on your operating 
system. When you run the program, it reads numbers from the standard input stream, which 
means whatever you type, the program reads. You then need to notify the program you are 
done by pressing the magic keystrokes that signal end-of-file. On most UNIX-like operating 
systems, press Control+D. On Windows, press Control+Z.
Running a console application from an IDE is sometimes tricky. If you aren’t careful, the 
IDE might close the program’s window before you have a chance to see any of its output. You 
need to ensure that the window remains visible. Some IDEs (such as Visual Studio and KDe-
velop) do this for you automatically, asking you to press a final Enter key before it closes the 
window.
If the IDE doesn’t keep the window open automatically, and you can’t find any option 
or setting to keep the window open, you can force the issue by setting a breakpoint on the 
EXPLORATION 1 N  HONING YOUR TOOLS
8
program’s closing curly brace or the nearest statement where the debugger will let you set a 
breakpoint.
Knowing how to run the program is one thing; another is to know what numbers to type 
so you can test the program effectively. How would you test heop,-,- to ensure it is running 
correctly?
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
Okay, do it. Does the program run correctly? ________________
There, that was easy, wasn’t it? You should try several different sequences. Run the pro-
gram with no input at all. Try it with one number. Try it with two that are already in order and 
two numbers that are in reverse order. Try a lot of numbers, in order. Try a lot of numbers in 
random order. Try a lot of numbers in reverse order.
Before you finish this Exploration, I have one more exercise. This time, the source file is 
more complicated. It was written by a professional stunt programmer. Do not attempt to read 
this program, even with adult supervision. Don’t try to make any sense of the program. Above 
all, don’t emulate the programming style used in this program. This exercise is not for you, but 
for your tools. Its purpose is to see whether your compiler can correctly compile this program 
and that your library implementation has the necessary parts of the standard library. It’s not a 
severe torture test for a compiler, but it does touch on a few advanced C++ features.
So don’t even bother trying to read the code. Just download the file heop,-,.*_ll from the 
book’s web site and try to compile and link it with your tools. (I include the full text of the pro-
gram only for readers who lack convenient Internet access.) If your compiler cannot compile 
and run Listing 1-2 correctly, you need to replace it (your compiler, not the program). You may 
be able to squeak by in the early lessons, but by the end of the book, you will be writing some 
fairly complicated programs, and you need a compiler that is up to the task. (By the way, List-
ing 1-2 pretty much does the same thing as Listing 1-1.)
Listing 1-2. Testing Your Compiler
+++ Oknp pda op]j`]n` ejlqp ]hld]^ape_]hhu*
+++ Na]` hejao kb patp( oknp pdai( ]j` lnejp pda naoqhpo pk pda op]j`]n` kqplqp*
+++ Eb pda _kii]j` heja j]iao ] beha( na]` bnki pd]p beha* Kpdanseoa( na]` bnki
+++ pda op]j`]n` ejlqp* Pda ajpena ejlqp eo opkna` ej iaiknu( ok `kjÑp pnu
+++ pdeo sepd ejlqp behao pd]p at_aa` ]r]eh]^ha N=I*
+++
+++ ?kil]neokj qoao ] hk_]ha j]ia` kj pda _kii]j` heja( kn pda `ab]qhp( qjj]ia`
+++ hk_]ha eb jk hk_]ha eo j]ia` kj pda _kii]j` heja*
ej_hq`a 8]hcknepdi:
ej_hq`a 8_op`he^:
ej_hq`a 8bopna]i:
ej_hq`a 8ekopna]i:
EXPLORATION 1 N  HONING YOUR TOOLS
9
ej_hq`a 8epan]pkn:
ej_hq`a 8hk_]ha:
ej_hq`a 8kopna]i:
ej_hq`a 8opnejc:
ej_hq`a 8ra_pkn:
+++ Na]` hejao kb patp bnki <l ej pk <l epan* Hejao ]na ]llaj`a` pk <l epan*
+++ <l]n]i ej pda ejlqp opna]i
+++ <l]n]i epan ]j kqplqp epan]pkn
pailh]pa8_h]oo ?d( _h]oo Pn( _h]oo KqpEpan:
rke` na]`$op`66^]oe_[eopna]i8?d(Pn:" ej( KqpEpan epan%
w
op`66^]oe_[opnejc8?d(Pn: heja7
sdeha $op`66capheja$ej( heja%%
w
&epan 9 heja7
''epan7
y
y
+++ Oknpan bqj_pekj k^fa_p*
+++ L]n]iapaneva pda _h]oo sepd pda _d]n]_pan pula qoa` bkn opnejco*
+++ Pda oknpan k^fa_p _]_dao ] hk_]ha ]j` epo <_ _khh]pa b]_ap( pk qoa bkn
+++ _kil]nejc opnejco*
pailh]pa8pulaj]ia ?d:
_h]oo oknpan
w
lq^he_6
+++ ?kjopnq_p pda oknpan k^fa_p( _]_dejc pda hk_]ha pd]p d]o pda ceraj j]ia*
+++ <l]n]i hk_j]ia Pda j]ia kb pda hk_]ha pk _]_da*
oknpan$?d _kjop& hk_j]ia% 6
hk_[$op`66hk_]ha$hk_j]ia%%(
_khh]pa[$op`66qoa[b]_ap8op`66_khh]pa8?d: :$hk_[%%
wy
+++ ?kjopnq_p ] `ab]qhp oknpan k^fa_p( qoejc pda chk^]h hk_]ha*
oknpan$% 6
hk_[$op`66hk_]ha$%%(
_khh]pa[$op`66qoa[b]_ap8op`66_khh]pa8?d: :$hk_[%%
wy
+++ ?kil]na bkn haoo)pd]j( bkn qoa ]o ] _kil]neokj lna`e_]pa sepd ]ju
+++ op]j`]n` ]hcknepdi*
+++ <l]n]i hdo habp)d]j` oe`a klan]j`
+++ <l]n]i ndo necdp)d]j` oe`a klan]j`
+++ <napqnj pnqa eb <l hdo 8 <l ndo ej pda ceraj hk_]ha( b]hoa kpdanseoa
pailh]pa8pulaj]ia Pn:
^kkh klan]pkn$%$_kjop op`66^]oe_[opnejc8?d(Pn:" hdo(
_kjop op`66^]oe_[opnejc8?d(Pn:" ndo%
EXPLORATION 1 N  HONING YOUR TOOLS
10
w
napqnj _khh]pa[*_kil]na$hdo*`]p]$%( hdo*`]p]$%'hdo*oeva$%(
ndo*`]p]$%( ndo*`]p]$%'ndo*oeva$%% 8 ,7
y
lner]pa6
op`66hk_]ha hk_[7
+++8 _]_da` hk_]ha
_kjop op`66_khh]pa8?d:" _khh]pa[7
+++8 _]_da` <_ _khh]pa b]_ap
y7
+++ I]ga ] oknpan k^fa_p ^u `a`q_ejc pda pailh]pa l]n]iapan*
+++ <l]n]i j]ia pda hk_]ha j]ia pk l]oo pk pda oknpan _kjopnq_pkn
+++ <napqnj ] jas oknpan k^fa_p
pailh]pa8pulaj]ia ?d:
oknpan8?d: i]ga[oknpan$?d _kjop & j]ia%
w
napqnj oknpan8?d:$j]ia%7
y
+++ I]ej lnkcn]i*
ejp i]ej$ejp ]nc_( _d]n& ]ncrWY%
pnu
w
++ Pdnks ]j at_alpekj eb ]j qjna_kran]^ha ejlqp annkn k__qno( a*c*(
++ `eog b]ehqna*
op`66_ej*at_alpekjo$op`66eko[^]oa66^]`^ep%7
++ L]np -* Na]` pda ajpena ejlqp ejpk patp* Eb pda _kii]j` heja j]iao ] beha(
++ na]` pd]p beha* Kpdanseoa( na]` pda op]j`]n` ejlqp*
op`66ra_pkn8op`66opnejc: patp7 +++8 Opkna pda hejao kb patp dana
eb $]nc_ 8 .%
na]`$op`66_ej( op`66^]_g[ejoanpan$patp%%7
ahoa
w
op`66ebopna]i ej$]ncrW-Y%7
eb $jkp ej%
w
op`66lannkn$]ncrW-Y%7
napqnj ATEP[B=EHQNA7
y
na]`$ej( op`66^]_g[ejoanpan$patp%%7
y
++ L]np .* Oknp pda patp* Pda oa_kj` _kii]j` heja ]ncqiajp( eb lnaoajp(
++ j]iao ] hk_]ha( pk _kjpnkh pda oknp kn`an* Sepdkqp ] _kii]j` heja
++ ]ncqiajp( qoa pda `ab]qhp hk_]ha $sde_d eo k^p]eja` bnki pda KO%*
op`66oknp$patp*^acej$%( patp*aj`$%( i]ga[oknpan$]nc_ :9 / ; ]ncrW.Y 6  %%7
EXPLORATION 1 N  HONING YOUR TOOLS
11
++ L]np /* Lnejp pda oknpa` patp*
op`66_klu$patp*^acej$%( patp*aj`$%(
op`66kopna]i[epan]pkn8op`66opnejc:$op`66_kqp( Xj%%7
y
_]p_d $op`66at_alpekj" at%
w
op`66_ann 88 ?]qcdp at_alpekj6  88 at*sd]p$% 88 #Xj#7
op`66_ann 88 Paniej]pejc lnkcn]i*Xj7
op`66atep$ATEP[B=EHQNA%7
y
_]p_d $***%
w
op`66_ann 88 ?]qcdp qjgjksj at_alpekj pula*XjPaniej]pejc lnkcn]i*Xj7
op`66atep$ATEP[B=EHQNA%7
y
I caught you peeking. In spite of my warning, you tried to read the source code, didn’t 
you? Just remember that I deliberately wrote this program in a complicated fashion to test 
your tools. By the time you finish this book, you will be able to read and understand this pro-
gram. Even more important, you will be able to write it more simply and more cleanly. Before 
you can run, however, you must learn to walk. Once you are comfortable working with your 
tools, it’s time to start learning C++. The next Exploration begins your journey with a reading 
lesson.
E X P L O R A T I O N  2
Reading C++ Code
I suspect you already have some knowledge of C++. Maybe you already know C, Java, Perl, or 
other C-like languages. Maybe you know so many languages that you can readily identify com-
mon elements. Let’s test my hypothesis. Take a few minutes to read Listing 2-1 then answer 
the questions that follow it.
Listing 2-1. Reading Test
- +++ Na]` pda lnkcn]i ]j` `apanieja sd]p pda lnkcn]i `kao*
.
/ ej_hq`a 8ekopna]i:
0 ej_hq`a 8eopna]i:
1 ej_hq`a 8heiepo:
2 ej_hq`a 8kopna]i:
3
4 ejp i]ej$%
5 w
-,
ejp iej$op`66jqiane_[heiepo8ejp:66i]t$%%7
--
ejp i]t$op`66jqiane_[heiepo8ejp:66iej$%%7
-.
^kkh ]ju$b]hoa%7
-/
ejp t7
-0
sdeha $op`66_ej :: t%
-1
w
-2
]ju 9 pnqa7
-3
eb $t 8 iej%
-4
iej 9 t7
-5
eb $t : i]t%
.,
i]t 9 t7
.-
y
..
./
eb $]ju%
.0
op`66_kqp 88 iej 9  88 iej 88 Xji]t 9  88 i]t 88 #Xj#7
.1 y
13
EXPLORATION 2 N  READING C++ CODE
14
What does Listing 2-1 do?
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
_________________________________________________________________________________
Listing 2-1 reads integers from the standard input and keeps track of the largest and 
smallest values entered. After exhausting the input, it then prints those values. If the input 
contains no numbers, the program prints nothing.
Let’s take a closer look at the various parts of the program.
Comments
Line 1 begins with three consecutive slashes to start a comment. The comment ends at the end 
of the line. Actually, you need only two slashes to signal the start of a comment (++), but as you 
will learn later in the book, three has a special meaning. For now though, use three.
Note that you cannot put a space between the slashes. That’s true in general for all the 
multicharacter symbols in C++. It’s an important rule, and one you must internalize early. 
A corollary of the “no spaces in a symbol” rule is that when C++ sees adjacent characters, it 
always tries to construct the longest possible symbol, even if you can see that doing so would 
produce meaningless results. I predict that this rule will surprise you several Explorations 
down the road.
The other method you can use to write a comment in C++ is to begin the comment with +&
and end it with &+. The difference between this style and the style demonstrated in Listing 2-1
is with this method, your comment can span multiple lines. You may notice that some pro-
grams in this book use +&& to start a comment. Much like the third slash in Listing 2-1, this 
second asterisk (&) is magic, but unimportant at this time. A comment cannot nest within 
a comment of the same style, but you can nest one style of comment in comments of the other 
style, as illustrated in Listing 2-2.
Listing 2-2. Demonstrating Comment Styles and Nesting
+& Op]np kb ] _kiiajp +& op]np kb _kiiajp _d]n]_pano ]na jkp ola_e]h ej ] _kiiajp
++ opehh ej ] _kiiajp
Opehh ej ] _kiiajp
&+
jk[hkjcan[ej[][_kiiajp$%7
++ Op]np kb ] _kiiajp +& op]np kb _kiiajp _d]n]_pano ]na jkp ola_e]h ej ] _kiiajp
jk[hkjcan[ej[][_kiiajp$%7
The C++ community uses both styles widely. Get used to seeing and using both styles.
Modify Listing 2-1 to change the +++ comment to use the +&& ... &+ style then try to recom-
pile the program. What happens?
_________________________________________________________________________________
EXPLORATION 2 N  READING C++ CODE
15
If you made the change correctly, the program should still compile and run normally. The 
compiler eliminates comments entirely, so nothing about the final program should be differ-
ent. (With one exception being that some binary formats include a timestamp, which would 
necessarily differ from one compilation run to another.)
Headers
Lines 3 through 6 import declarations and definitions from parts of the standard library. C++, 
like C and many other languages, distinguishes between the core language and the standard 
library. Both are part of the standard language, and a tool suite is incomplete without both 
parts. The difference is that the core language is self-contained. For example, certain types 
are built in, and the compiler inherently knows about them. Other types are defined in terms 
of the built-in types, so they are declared in the standard library, and you need to instruct the 
compiler that you want to use them. That’s what lines 3 through 6 are all about.
In particular, line 3 informs the compiler about the names of the standard I/O streams 
(_ej for the standard input and _kqp for the standard output). Line 4 fetches the input operator 
(::), line 5 brings in the name jqiane_[heiepo, and line 6 brings in the output operator (88).
Note that names from the standard library generally begin with op`66 (short for “standard”).
In C++ parlance, the ej_hq`a keyword is also a verb, as in “line 3 includes the ekopna]i
header,” “line 5 includes the heiepo header,” and so on. A header is typically a file that contains 
a series of declarations and definitions. (A declaration is a kind of definition. A definition tells 
the compiler more about a name than a declaration. Don’t worry about the difference yet, but 
notice when I use declaration and when I use definition.) The compiler needs these declara-
tions and definitions so it knows what to do with names such as op`66_ej. Somewhere in the 
documentation for your C++ compiler and standard library is the location for its standard 
headers. If you are curious, visit that folder or directory and see what you can find there, but 
don’t be disappointed that you can’t read the headers. The C++ standard library makes full use 
of the entire range of C++ language features. It’s likely you won’t be able to decipher most of 
the library until after you’ve made it through a large part of this book.
Another important C++ rule: the compiler needs to know what every name means. 
A human can often infer meaning or at least a part of speech from context. For instance, if 
I were to say, “I furbled my drink all over my shirt,” you may not know exactly what “furbled” 
means, but you can deduce that it is the past tense of a verb, and that it probably is something 
undesirable and somewhat messy.
C++ compilers are a lot dumber than you. When the compiler reads a symbol or identifier, 
it must know exactly what the symbol or identifier means and what part of “speech” it is. Is the 
symbol a punctuator (such as the statement-ending semicolon) or an operator (such as plus 
sign for addition)? Is the identifier a type? A function? A variable? The compiler also needs to 
know everything you can do with that symbol or name, so it can correctly compile the code. 
The only way it can know is for you to tell it, and the way you tell it is by writing a declara-
tion or by importing a declaration from a header. And that’s what ej_hq`a statements are all 
about.
Any line that begins with , ends at the end of the line. C++ has several different  state-
ments, but only ej_hq`a concerns us at this time. Inside the angle brackets must be a header
name, which is typically a standard library header, but it might also be a header from a third- 
party library.
Later in the book, you’ll even learn to write your own headers.