Successfully reported this slideshow.
We use your LinkedIn profile and activity data to personalize ads and to show you more relevant ads. You can change your ad preferences anytime.
;-_=_Scrolldown to the Underground_=_-;              Thinking in C++ 2nd #1                                   http://kickm...
Winner, Software Development Magazine’s1996 Jolt Award for Best Book of the Year“This book is a tremendous achievement. Yo...
whenever possible, and to that effect, “Thinking in C++” has given me the strongComments from Readers:                    ...
I would like to thank you for your book “Thinking in C++” which is, with nodoubt, the best book I ever read about this sub...
Publisher: Alan AptProduction Editor: Scott DisannoExecutive Managing Editor: Vince OBrien                                ...
Dedication                                                                       To my parents, my sister, and my brother ...
What’s inside...Preface                                   1      1: Introduction to    What’s new in                      ...
Phase 5: Evolution ..............58                                                              Modifying the      Plans ...
Returning by const value ... 345                Other storage     Exercises..............254                       Aggrega...
Stash for pointers ............ 55812: Operator                                                                           ...
on and off.............713    Holding objects    by value ...............716    Introducing    iterators ...............71...
You can’t just look at C++ as a collection of features; some of the         on a day-to-day basis but that the C++ and Jav...
many new words intuitively by seeing them in context in a novel, it’s                  issues. I found out, by creating an...
2.   Use examples that are as simple and short as possible. This          7.    I’ve tried not to use any particular vendo...
Here is a brief description of the chapters contained in this book:      by the simple act of putting functions inside str...
Chapter 9: Inline Functions. Preprocessor macros eliminate                delete elegantly solve this problem by safely cr...
All rights reserved EXCEPT as allowed by theExercises                                                                  fol...
You may use the code in your projects and in the classroom as long      Thus, ‘ISO’ is the correct way to refer to the C++...
CD ROMs, seminars,                                                          About the coverand consulting                 ...
Book design and production                                                   Acknowledgements  The book’s interior design ...
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Thinking in c++ volume1
Upcoming SlideShare
Loading in …5
×

Thinking in c++ volume1

1,934 views

Published on

  • Be the first to comment

Thinking in c++ volume1

  1. 1. ;-_=_Scrolldown to the Underground_=_-; Thinking in C++ 2nd #1 http://kickme.to/tiger/
  2. 2. Winner, Software Development Magazine’s1996 Jolt Award for Best Book of the Year“This book is a tremendous achievement. You owe it to yourself tohave a copy on your shelf. The chapter on iostreams is the mostcomprehensive and understandable treatment of that subject I’veseen to date.” Al Stevens Contributing Editor, Doctor Dobbs Journal“Eckel’s book is the only one to so clearly explain how to rethinkprogram construction for object orientation. That the book is alsoan excellent tutorial on the ins and outs of C++ is an added bonus.” Andrew Binstock Editor, Unix Review“Bruce continues to amaze me with his insight into C++, andThinking in C++ is his best collection of ideas yet. If you want clearanswers to difficult questions about C++, buy this outstandingbook.” Gary Entsminger Author, The Tao of Objects“Thinking in C++ patiently and methodically explores the issues ofwhen and how to use inlines, references, operator overloading,inheritance and dynamic objects, as well as advanced topics such asthe proper use of templates, exceptions and multiple inheritance.The entire effort is woven in a fabric that includes Eckel’s ownphilosophy of object and program design. A must for every C++developer’s bookshelf, Thinking in C++ is the one C++ book youmust have if you’re doing serious development with C++.” Richard Hale Shaw Contributing Editor, PC Magazine
  3. 3. whenever possible, and to that effect, “Thinking in C++” has given me the strongComments from Readers: foundation for my continuous improvement. Peter Tran, Senior Systems Analyst (IM), Compaq Computer CorporationWonderful book … Great stuff! Andrew Schulman, Doctor Dobbs Journal This book is the best general reference in my on-going quest to master C++. MostAn absolute, unqualified must. One of the most-used, most trusted books on my books explain some topics thoroughly but are deficient in others. “Thinking inshelf.” TUG Lines C++” 2/E does not pass the buck to another book. When I have questions it hasThis is stuff a programmer can really use. IEEE Computer answers. Thomas MichelA refreshing departure. PJ Plauger, Embedded Systems Programming I have a whole mountain of books and none of them make sense nor do theymagazine explain things properly. I have been dying for a good template and STL book. Then I decided to read your material and I was amazed. What you did was show…Eckel succeeds … it’s so readable. Unix World how to write C++ with templates and STL without bogging down with details. What you did was what I expected of the C++ community, the next generation ofShould definitely be your first buy. C Gazette C++ authors. As an author I AM IMPRESSED at your writing and explanationA fantastic reference for C++! Michael Brandt, Senior Analyst/Programmer, skills. You covered topics that nobody has properly covered before. YourSydney, Australia approach is one from a person who has actually sat down and went through the material in detail. And then you questioned the sanity of the situation and whatOn our project at HRB Systems we call your book “The Answer Book”. It is our would be the problem areas. On my bookshelf, it will definitely be one of theC++ Bible for the project. Curt Snyder, HRB Systems necessary books, right beside Petzold. Christian Gross, consultant/mentorYour book is really great, and I can’t thank you enough for making it available for cgross@eusoft.comfree on the web. It’s one of the most thorough and useful references for C++ I’ve I think your book is very, very, VERY good. I have compared it to others in theseen. Russell Davis bookstore, and have found that your book actually teaches me basic C++... the only book out there that even comes close to being actually readable when fundamentals while I learn the STL... a very nice experience to learn about bothtrying to learn the ropes of C++ (and the basics of good object oriented at once, hand-in-hand. I think your book is laid out very well, and explains thingsprogramming in general). Gunther Schulz, KawaiiSoft in an easy-to-understand fashion. Jeff Meininger, Software Developer, boxybutgood.comI love the examples in your book. There’s stuff there that I never would havethought of (and some things that I didn’t know you could do)! Rich Herrick, Your book is the best by far of any I’ve seen. Please get it right so that we can allSenior Associate Software Engineer, Lockheed-Martin Federal Systems, have an excellent and “reliable” reference work! And please hurry! We areOwego, NY desperate for a work of this quality! Steve Strickland, Live Minds (a Puzzle business)It’s an amazing book. Any questions I have I refer to this online book. Helped inevery case. I’m simply happy to have access to a book of this caliber. Wes Kells, (On Usenet) Unlike most other C++ authors, Eckel has made a career of teaching C++ and Java classes ONLY. He’s had the benefit of a GREAT deal of noviceComp Eng. Student, SLC Kingston. feedback, and the books reflect that. His books are not just about writing inYou are an invaluable resource and I greatly appreciate your books, email list C++/Java, but understanding the intent of the languages and the mindset thatetc... It seems every project I have worked on has been successful because of your goes with thinking in them. Eckel’s also the best technical writer I’ve read sinceinsights. Justin Voshell Jeff Duntemann. Very clear and easy to read. Don’t be put off by the apparent large size of his books. Either can be read in *less* than 21 days. :-} RandyThis is the book I have been looking for on C++. Thomas A. Fink, Managing Crawford, MRJ Technology Solutions, Fairfax VADirector, Trepp, LLC Your work is greatly appreciated and I thank you for helping me understand bothYour books are authoritative yet easy to read. To my colleagues I call you the C++ and Java better. Barry Wallin, Math/Computer Science Teacher,K&R of C++. Mark Orlassino, Senior Design Engineer, Harmon Rosemount High School, Rosemount, MNIndustries, Inc., Hauppauge, NYWhen I first started learning C++, your book “Thinking in C++” was my shiningguide light in a dark tunnel. It has been my endeavor to improve my C++ skills
  4. 4. I would like to thank you for your book “Thinking in C++” which is, with nodoubt, the best book I ever read about this subject. Riccardo Tarli - SWEngineer - R&D TXT Ingegneria Informatica - Italy ThinkingI have been reading both of your books, Thinking In Java and Thinking In C++.Each of these books is easily the best in its category. Ranakarprasad H. Tiwari,Mumbai, India… the “Debugging Hints” section is so valuable, I’m tempted to print it and keepit with me at all times. I think this section should be a mandatory part of anyintroductory class after the first one or two programming problems. FredBallard, Synectics Inc. InYour book is really a treasure trove of C++ knowledge. I feel like you give a goodoverview and then explain the nuts and bolts. Raymond Pickles, AntennaSection, Radar Division, U.S. Naval Research Laboratory, WashingtonDCAs an Internal Medicine Specialist and Computer Scientist I spend a great deal oftime trying to extract information from books and journals. My experience is that C++a good author is one who makes difficult concepts accessible, a great one makes itlook almost easy. On this score you are certainly one of my top three technicalwriters. Keep up the good work. Dr. Declan O’Kane, Leicester, EnglandFor my second-level C++ course, “Thinking in C++” is my constant reference andcompanion, and I urge my students to consult it regularly. I refer to the chapteron Operator Overloading constantly. The examples/code alone are worth the costof the book many times over. So many books and development environments arepredicated on the assumption that the only application for a programminglanguage is for a Windows environment; it’s great to find and use a book which Second Editionconcentrates on C++ so we can prepare our students for careers in fields likeembedded systems, networking, etc., which require real depth of understanding.Robert Chase, Professor, Sweet Briar CollegeI think it’s a fantastic intro to C++, especially for longtime dabblers like me – I Bruce Eckeloften know “how,” but rarely “why,” and TIC2 is a godsend. Tony Likhite,System Administrator/DBA, Together Networks President, MindView Inc.After reading the first 80 pages of this book, I have a better understanding of oopthen Ive gotten out of the ton of books Ive accumulated on the subject. Thanks...Rick Schneewind Prentice Hall Upper Saddle River, New Jersey 07458 http://www.prenhall.com
  5. 5. Publisher: Alan AptProduction Editor: Scott DisannoExecutive Managing Editor: Vince OBrien PublicVice President and Editorial Director: Marcia HortonVice President of Production and Manufacturing: David W. Riccardi C++ SeminarsProject Manager: Ana TerryBook Design, Cover Design and Cover Line Art: Check www.BruceEckel.com Daniel Will-Harris, daniel@will-harris.com for in-depth details and the dateCover Watercolor: Bruce EckelCopy Editor: Stephanie English and location of the next:Production Coordinator: Lori BulwinEditorial Assistant: Toni Holm Hands-On C++ SeminarMarketing Managers: Jennie Burger, Bryan Gambrel x Based on this book x Get a solid grounding in Standard C++ fundamentals©2000 by Bruce Eckel, MindView, Inc. x Includes in-class programming exercises Published by Prentice Hall Inc. x Personal attention during exercises Pearson Higher Education Upper Saddle River, New Jersey 07632 Intermediate C++ SeminarThe information in this book is distributed on an “as is” basis, without warranty. While x Based on Volume 2 of this book (downloadable atevery precaution has been taken in the preparation of this book, neither the author nor the www.BruceEckel.com)publisher shall have any liability to any person or entitle with respect to any liability, lossor damage caused or alleged to be caused directly or indirectly by instructions contained in x In-depth coverage of the Standard C++ Librarythis book or by the computer software or hardware products described herein. x Strings, containers, iterators, algorithmsAll rights reserved. No part of this book may be reproduced in any form or by any x In-depth templates & exception handlingelectronic or mechanical means including information storage and retrieval systemswithout permission in writing from the publisher or author, except by a reviewer who may Advanced C++ Topicsquote brief passages in a review. Any of the names used in the examples and text of thisbook are fictional; any relationship to persons living or dead or to fictional characters in x Based on advanced topics in Volume 2 of this bookother works is purely coincidental. x Design patternsPrinted in the United States of America x Building robust systems x Creating testing & debugging frameworks10 9 8 7 6 5 4 3 2 1ISBN 0-13-979809-9 Subscribe to the free newsletterPrentice-Hall International (UK) Limited, LondonPrentice-Hall of Australia Pty. Limited, Sydney to be automatically informedPrentice-Hall Canada, Inc., Toronto of upcoming seminarsPrentice-Hall Hispanoamericana, S.A., MexicoPrentice-Hall of India Private Limited, New DelhiPrentice-Hall of Japan, Inc., Tokyo Also visit www.BrucEckel.com for:Pearson Education Asia Ltd., SingaporeEditora Prentice-Hall do Brasil, Ltda., Rio de Janeiro „ Consulting Services „ Exercise solutions for this book
  6. 6. Dedication To my parents, my sister, and my brother Seminars-on-CD-ROM If you like the Thinking in C Seminar-on-CD packaged with this book, then you’ll also like: ruce Eckel’s ands-On C++ SeminarMultimedia CD ROMt’s like coming to the seminar! vailable at www.BruceEckel.com Overhead slides and synchronized audio recorded by Bruce Eckel All the lectures from the Hands-On C++ Seminar Based on this book Get a solid grounding in Standard C++ Fundamentals Just play it to see and hear the lectures! Lectures are indexed so you can rapidly locate the discussion of any subject Details and sample lecture can be found on the Web siteee www.BruceEckel.comor other Seminars-on-CD ROM The Intermediate C++ Seminar Advanced C++ Topics
  7. 7. What’s inside...Preface 1 1: Introduction to What’s new in Objects 21 the second edition .... 2 The progress of What’s in Volume 2 of this book......................... 3 abstraction............. 22 How to get Volume 2............ 3 An object has an Prerequisites............ 3 interface ................ 25 Learning C++ .......... 4 The hidden Goals ...................... 5 implementation ...... 28 Chapters ................. 7 Reusing the Exercises............... 12 implementation ...... 29 Exercise solutions ...............12 Inheritance: reusing Source code........... 12 the interface .......... 31 Language Is-a vs. is-like-a standards .............. 14 relationships...................... 35 Language support ...............15 Interchangeable The book’s objects with CD ROM ................ 15 polymorphism ........ 37 CD ROMs, seminars, Creating and and consulting ....... 16 destroying objects... 41 Errors ................... 16 Exception handling: About the cover...... 17 dealing with errors .. 43 Book design and Analysis production ............. 18 and design ............. 44 Acknowledgements . 19 Phase 0: Make a plan.......... 47 Phase 1: What are we making?....................... 48 Phase 2: How will we build it? ....................... 52 Phase 3: Build the core ....... 56 Phase 4: Iterate the use cases .................... 57
  8. 8. Phase 5: Evolution ..............58 Modifying the Plans pay off ......................60 More about outside object .................. 137 Function Extreme iostreams .............. 96 Introduction to addresses ............ 198 Character array C++ references ................ 140 Defining a programming ......... 61 concatenation .................... 96 Pointers and references function pointer ............... 198 Write tests first...................61 Reading input .................... 97 as modifiers ..................... 141 Complicated declarations Pair programming ...............63 Calling other programs........ 98 & definitions .................... 199 Scoping................143 Using a function pointer .... 200 Why C++ Introducing Defining variables Arrays of pointers on the fly......................... 145 succeeds ............... 64 strings................... 98 to functions ..................... 201 A better C ..........................65 Reading and Specifying storage Make: managing You’re already on the learning curve...............65 writing files .......... 100 allocation .............147 separate Global variables ................ 147 Efficiency ...........................66 Systems are easier to Introducing Local variables ................. 149 compilation .......... 202 static .............................. 149 Make activities ................. 204 express and understand.......66 vector ................. 102 extern ............................. 151 Makefiles in this book ....... 207 Maximal leverage with libraries ......................67 Summary............. 108 Constants ........................ 153 An example makefile ........ 208 volatile ............................ 155 Source-code reuse Exercises ............. 109 Summary............. 210 with templates ...................67 Operators and Exercises ............. 210 Error handling ....................67 Programming in the large.....68 3: The C in C++ 111 their use ..............156 Assignment ...................... 156 Strategies for Creating Mathematical operators ..... 156 4: Data Abstraction 217 Relational operators .......... 158 transition............... 68 functions ............. 112 Logical operators .............. 158 A tiny C-like Guidelines..........................69 Function return values ...... 115 Management obstacles ........71 Using the C Bitwise operators .............. 159 library ................. 219 Shift operators ................. 160 Dynamic Summary .............. 73 function library ................ 116 Unary operators................ 163 storage allocation............. 223 Creating your own The ternary operator ......... 164 Bad guesses .................... 227 libraries with the librarian.. 117 The comma operator ......... 1652: Making & Using Controlling Common pitfalls Whats wrong?...... 229Objects 75 execution............. 117 when using operators ........ 166 The basic object.... 230 Casting operators ............. 166 True and false ................. 117 C++ explicit casts............. 167 Whats an object? . 238 The process of if-else ............................. 118 sizeof – an operator Abstract language while .............................. 119 by itself ........................... 172 do-while ......................... 120 The asm keyword ............. 173 data typing .......... 239 translation ............. 76 for ................................. 121 Interpreters .......................77 The break and Explicit operators .............. 173 Object details ....... 240 Compilers ..........................77 continue keywords ........... 122 Composite type Header file The compilation process.......79 switch............................. 123 creation ...............174 etiquette.............. 241 Tools for separate Using and misusing goto ... 125 Aliasing names Importance of Recursion........................ 126 with typedef..................... 174 compilation............ 80 header files ..................... 242 Declarations vs. definitions...81 Introduction to Combining variables The multiple-declaration with struct ....................... 175 problem .......................... 244 Linking ..............................87 operators ............. 127 Clarifying programs The preprocessor directives Using libraries ....................88 Precedence...................... 127 with enum ....................... 179 #define, #ifdef, Your first Auto increment Saving memory and #endif ...................... 245 and decrement ................ 128 with union ....................... 181 C++ program ........ 90 A standard for header files 246 Using the iostreams class.....90 Introduction to Arrays ............................. 182 Namespaces in headers .... 247 Namespaces.......................91 data types ........... 129 Debugging hints ....193 Using headers in projects .. 248 Fundamentals of Basic built-in types ........... 129 Debugging flags................ 194 Nested structures.. 248 program structure...............93 bool, true, & false ............ 131 Turning variables and Global scope resolution ..... 253 "Hello, world!" ....................94 Specifiers ........................ 132 expressions into strings ..... 196 Running the compiler ..........95 Introduction to pointers .... 133 The C assert( ) macro........ 197 Summary............. 253
  9. 9. Returning by const value ... 345 Other storage Exercises..............254 Aggregate Passing and returning class specifiers................. 414 initialization ......... 301 addresses ........................ 349 Namespaces......... 4145: Hiding the Default Classes ................352 Creating a namespace ...... 415 const in classes ................ 353 Using a namespace .......... 417Implementation 259 constructors ......... 304 Compile-time constants The use of namespaces ..... 422 Setting limits ........260 Summary............. 305 in classes......................... 356 Static members const objects & C++ access Exercises ............. 306 member functions ............. 359 in C++ ................ 423 Defining storage for control .................261 volatile.................365 protected......................... 263 7: Function Overloading Summary .............367 static data members ......... 424 Nested and local classes.... 428 Friends.................263 & Default Exercises..............367 static member functions .... 429 Nested friends .................. 266 Static initialization Is it pure?........................ 269 Arguments 309 Object layout ........269 9: Inline Functions 371 dependency ......... 432 More name What to do ...................... 434 The class ..............270 decoration ........... 311 Preprocessor Alternate linkage Modifying Stash to use Overloading on access control .................. 273 return values ................... 312 pitfalls .................372 specifications........ 442 Modifying Stack to use Macros and access ............ 376 Type-safe linkage ............. 313 Summary............. 443 access control .................. 274 Overloading Inline functions .....377 Handle classes ......275 Inlines inside classes ......... 378 Exercises ............. 443 Hiding the example .............. 314 Access functions ............... 379 implementation ................ 276 Reducing recompilation...... 276 unions ................. 318 Stash & Stack 11: References & the Default with inlines ...........385 Copy-Constructor 449 Summary .............279 arguments ........... 321 Inlines & Exercises..............280 Placeholder arguments...... 323 Pointers in C++ .... 450 the compiler .........390 Choosing overloading Limitations....................... 390 References6: Initialization & vs. default Forward references ........... 391 in C++ ................ 451 Hidden activities in References in functions ..... 452Cleanup 283 arguments ........... 324 constructors & Argument-passing destructors ...................... 392 Guaranteed Summary............. 329 guidelines ....................... 455 Exercises ............. 330 Reducing clutter ....393 The copy- initialization with the More preprocessor constructor .......... 455 constructor ...........285 8: Constants 333 features ...............395 Passing & returning Guaranteed cleanup Token pasting .................. 396 by value.......................... 455 Copy-construction ............ 462 with the Value substitution . 334 Improved error Default copy-constructor ... 468 const in header files ......... 335 destructor ............287 Safety consts................... 336 checking ..............396 Alternatives to copy- construction .................... 471 Elimination of the Aggregates...................... 337 Summary .............400 definition block......289 Differences with C ............ 338 Pointers Exercises..............400 for loops .......................... 291 Pointers ............... 340 to members ......... 473 Storage allocation ............. 292 Pointer to const ............... 340 Functions ........................ 475 Stash with const pointer ................... 341 10: Name Control 405 Summary............. 478 Assignment and constructors and type checking .................. 343 Static elements Exercises ............. 479 destructors ...........294 Function arguments & from C .................406 static variables Stack with constructors return values........ 344 inside functions ................ 406 Passing by const value ...... 344 & destructors ........298 Controlling linkage ............ 412
  10. 10. Stash for pointers ............ 55812: Operator Choosing composition Abstract base classes new & delete vs. inheritance ......604 and pure virtualOverloading 485 for arrays............. 563 Subtyping ........................ 606 functions ............. 646 Warning & Making a pointer private inheritance ............ 609 Pure virtual definitions ...... 651 more like an array............ 564 reassurance ..........486 protected .............610 Inheritance and Running out protected inheritance ........ 611 Syntax .................487 the VTABLE .......... 652 of storage ............ 565 Operator overloading Overloadable Object slicing................... 655 Overloading & inheritance ........612 Overloading & operators .............488 Unary operators................ 489 new & delete ........ 566 Multiple overriding ............ 658 Overloading global Binary operators ............... 493 new & delete ................... 568 inheritance ...........613 Variant return type........... 660 Arguments & return values.................... 505 Overloading Incremental virtual functions & new & delete for a class .... 570 Unusual operators............. 508 Overloading development.........614 constructors ......... 662 Operators you Order of constructor calls .. 663 can’t overload .................. 517 new & delete for arrays..... 573 Upcasting .............615 Behavior of virtual functions Constructor calls .............. 576 Why “upcasting?”.............. 617 Non-member placement new & delete .... 577 Upcasting and the inside constructors ........... 664 operators .............518 Summary............. 580 copy-constructor............... 617 Destructors and Composition vs. Basic guidelines ................ 520 Exercises ............. 580 inheritance (revisited) ....... 620 virtual destructors. 665 Overloading Pointer & reference Pure virtual destructors..... 668 Virtuals in destructors....... 670 assignment...........521 upcasting......................... 622 Behavior of operator= ....... 522 14: Inheritance & A crisis ............................ 622 Creating an object-based hierarchy ..... 671 Automatic type Composition 583 Summary .............623 Operator conversion............533 Composition Exercises..............623 overloading .......... 675 Constructor conversion ...... 534 Operator conversion.......... 535 syntax................. 584 Downcasting ........ 678 Type conversion example... 538 Inheritance 15: Polymorphism & Summary............. 681 Pitfalls in automatic type conversion ................ 539 syntax................. 586 Virtual Functions 627 Exercises ............. 682 Summary .............542 The constructor Evolution of C++ Exercises..............542 initializer list ........ 588 programmers ........628 16: Introduction to Member object initialization..................... 589 Upcasting .............629 Templates 68913: Dynamic Built-in types in the The problem .........631 Containers ........... 690 initializer list.................... 589 Function call binding ......... 631Object Creation 547 Combining composition virtual functions ....632 The need for containers .... 692 Overview Object creation......549 & inheritance........ 591 Extensibility ..................... 633 C’s approach to the heap ... 550 Order of constructor & How C++ implements of templates......... 693 operator new.................... 552 The template solution ....... 696 destructor calls ................ 592 operator delete................. 553 late binding ..........636 Template syntax ... 697 A simple example ............. 553 Name hiding......... 595 Storing type information .... 637 Non-inline Picturing virtual functions... 639 Memory manager Functions that Under the hood ................ 642 function definitions ........... 699 overhead ......................... 554 IntStack as a template...... 701 don’t automatically Installing the vpointer ....... 643 Early examples Objects are different ......... 644 Constants in templates ..... 703 inherit ................. 600 Stack and Stash redesigned ...........555 Inheritance and static Why virtual delete void* is member functions ............ 604 functions?.............645 as templates ........ 705 probably a bug ................. 555 Templatized pointer Stash . 707 Cleanup responsibility with pointers .................... 557 Turning ownership
  11. 11. on and off.............713 Holding objects by value ...............716 Introducing iterators ...............719 Stack with iterators ........... 728 PStash with iterators ......... 732 Why iterators? ......738 Function templates............ 742 Summary .............743 Exercises..............744A: Coding Style 747B: ProgrammingGuidelines 759C: RecommendedReading 775 C.........................776 General C++.........776 My own list of books.......... 777 Depth & dark corners .........778 Analysis & design ..779Index 783 Preface Like any human language, C++ provides a way to express concepts. If successful, this medium of expression will be significantly easier and more flexible than the alternatives as problems grow larger and more complex.
  12. 12. You can’t just look at C++ as a collection of features; some of the on a day-to-day basis but that the C++ and Java languages steer you features make no sense in isolation. You can only use the sum of the away from (or even eliminate, in the case of Java). parts if you are thinking about design, not simply coding. And to understand C++ this way, you must understand the problems with So the short answer to the question “what’s different in the 2nd C and with programming in general. This book discusses edition?” is: what isn’t brand new has been rewritten, sometimes to programming problems, why they are problems, and the approach the point where you wouldn’t recognize the original examples and C++ has taken to solve such problems. Thus, the set of features I material. explain in each chapter will be based on the way that I see a particular type of problem being solved with the language. In this What’s in Volume 2 of this book way I hope to move you, a little at a time, from understanding C to the point where the C++ mindset becomes your native tongue. The completion of the C++ Standard also added a number of important new libraries, such as string and the containers and Throughout, I’ll be taking the attitude that you want to build a algorithms in the Standard C++ Library, as well as new complexity model in your head that allows you to understand the language all in templates. These and other more advanced topics have been the way down to the bare metal; if you encounter a puzzle, you’ll be relegated to Volume 2 of this book, including issues such as able to feed it to your model and deduce the answer. I will try to multiple inheritance, exception handling, design patterns, and convey to you the insights that have rearranged my brain to make topics about building and debugging stable systems. me start “thinking in C++.” How to get Volume 2 Just like the book you currently hold, Thinking in C++, Volume 2 isWhat’s new in the second edition downloadable in its entirety from my Web site at This book is a thorough rewrite of the first edition to reflect all of www.BruceEckel.com. You can find information on the Web site the changes introduced in C++ by the finalization of the C++ about the expected print date of Volume 2. Standard, and also to reflect what I’ve learned since writing the first edition. The entire text present in the first edition has been The Web site also contains the source code for both of the books, examined and rewritten, sometimes removing old examples, often along with updates and information about other seminars-on-CD changing existing examples and adding new ones, and adding many ROM that MindView, Inc. offers, public seminars, and in-house new exercises. Significant rearrangement and re-ordering of the training, consulting, mentoring, and walkthroughs. material took place to reflect the availability of better tools and my improved understanding of how people learn C++. A new chapter was added which is a rapid introduction to the C concepts and basic Prerequisites C++ features for those who don’t have the C background to tackle In the first edition of this book, I decided to assume that someone the rest of the book. The CD ROM bound into the back of the book else had taught you C and that you have at least a reading level of contains a seminar that is an even gentler introduction to the C comfort with it. My primary focus was on simplifying what I found concepts necessary to understand C++ (or Java). It was created by difficult: the C++ language. In this edition I have added a chapter Chuck Allison for my company (MindView, Inc.), and it’s called that is a rapid introduction to C, along with the Thinking in C “Thinking in C: Foundations for Java and C++.” It introduces you to seminar-on-CD, but I am still assuming that you already have some the aspects of C that are necessary for you to move on to C++ or kind of programming experience. In addition, just as you learn Java, leaving out the nasty bits that C programmers must deal with 2 Thinking in C++ www.BruceEckel.com Preface 3
  13. 13. many new words intuitively by seeing them in context in a novel, it’s issues. I found out, by creating and chairing the C++ and Java possible to learn a great deal about C from the context in which it is tracks at the Software Development Conference for many years, used in the rest of the book. that I and other speakers tended to give the typical audience too many topics, too fast. So eventually, through both variety in the audience level and the way that I presented the material, I wouldLearning C++ end up losing some portion of the audience. Maybe it’s asking too much, but because I am one of those people resistant to traditional I clawed my way into C++ from exactly the same position I expect lecturing (and for most people, I believe, such resistance results many of the readers of this book are in: as a programmer with a from boredom), I wanted to try to keep everyone up to speed. very no-nonsense, nuts-and-bolts attitude about programming. Worse, my background and experience was in hardware-level For a time, I was creating a number of different presentations in embedded programming, in which C has often been considered a fairly short order. Thus, I ended up learning by experiment and high-level language and an inefficient overkill for pushing bits iteration (a technique that also works well in C++ program design). around. I discovered later that I wasn’t even a very good C Eventually I developed a course using everything I had learned programmer, hiding my ignorance of structures, malloc( ) and from my teaching experience. It tackles the learning problem in free( ), setjmp( ) and longjmp( ), and other “sophisticated” discrete, easy-to-digest steps and for a hands-on seminar (the ideal concepts, scuttling away in shame when the subjects came up in learning situation) there are exercises following each of the conversation instead of reaching out for new knowledge. presentations. You can find out about my public seminars at www.BruceEckel.com, and you can also learn about the seminars When I began my struggle to understand C++, the only decent book that I’ve turned into CD ROMs. was Bjarne Stroustrup’s self-professed “expert’s guide,1” so I was left to simplify the basic concepts on my own. This resulted in my The first edition of this book developed over the course of two years, first C++ book,2 which was essentially a brain dump of my and the material in this book has been road-tested in many forms in experience. That was designed as a reader’s guide to bring many different seminars. The feedback that I’ve gotten from each programmers into C and C++ at the same time. Both editions3 of seminar has helped me change and refocus the material until I feel the book garnered enthusiastic response. it works well as a teaching medium. But it isn’t just a seminar handout; I tried to pack as much information as I could within At about the same time that Using C++ came out, I began teaching these pages, and structure it to draw you through onto the next the language in seminars and presentations. Teaching C++ (and subject. More than anything, the book is designed to serve the later, Java) became my profession; I’ve seen nodding heads, blank solitary reader who is struggling with a new programming language. faces, and puzzled expressions in audiences all over the world since 1989. As I began giving in-house training to smaller groups of people, I discovered something during the exercises. Even those people who were smiling and nodding were confused about many Goals My goals in this book are to: 1 Bjarne Stroustrup, The C++ Programming Language, Addison-Wesley, 1986 (first 1. Present the material one simple step at a time, so the reader edition). 2 Using C++, Osborne/McGraw-Hill 1989. can easily digest each concept before moving on. 3 Using C++ and C++ Inside & Out, Osborne/McGraw-Hill 1993. 4 Thinking in C++ www.BruceEckel.com Preface 5
  14. 14. 2. Use examples that are as simple and short as possible. This 7. I’ve tried not to use any particular vendor’s version of C++ often prevents me from tackling “real world” problems, but because, for learning the language, I don’t think that the I’ve found that beginners are usually happier when they can details of a particular implementation are as important as the understand every detail of an example rather than being language itself. Most vendors’ documentation concerning impressed by the scope of the problem it solves. Also, there’s their own implementation specifics is adequate. a severe limit to the amount of code that can be absorbed in a classroom situation. For this I sometimes receive criticism for using “toy examples,” but I’m willing to accept that in favor of Chapters producing something pedagogically useful. C++ is a language in which new and different features are built on3. Carefully sequence the presentation of features so that you top of an existing syntax. (Because of this, it is referred to as a aren’t seeing something you haven’t been exposed to. Of hybrid object-oriented programming language.) As more people course, this isn’t always possible; in those situations, a brief pass through the learning curve, we’ve begun to get a feel for the introductory description will be given. way programmers move through the stages of the C++ language features. Because it appears to be the natural progression of the4. Give you what I think is important for you to understand procedurally-trained mind, I decided to understand and follow this about the language, rather than everything that I know. I same path and accelerate the process by posing and answering the believe there is an “information importance hierarchy,” and questions that came to me as I learned the language and those there are some facts that 95 percent of programmers will questions that came from audiences as I taught the language. never need to know and that would just confuse them and add to their perception of the complexity of the language. To This course was designed with one thing in mind: to streamline the take an example from C, if you memorize the operator process of learning C++. Audience feedback helped me understand precedence table (I never did), you can write clever code. But which parts were difficult and needed extra illumination. In the if you have to think about it, it will confuse the areas in which I got ambitious and included too many features all at reader/maintainer of that code. So forget about precedence, once, I came to know – through the process of presenting the and use parentheses when things aren’t clear. This same material – that if you include a lot of new features, you have to attitude will be taken with some information in the C++ explain them all, and the student’s confusion is easily compounded. language, which I think is more important for compiler As a result, I’ve taken a great deal of trouble to introduce the writers than for programmers. features as few at a time as possible; ideally, only one major concept at a time per chapter.5. Keep each section focused enough so the lecture time – and the time between exercise periods – is reasonable. Not only The goal, then, is for each chapter to teach a single concept, or a does this keep the audience’s minds more active and involved small group of associated concepts, in such a way that no additional during a hands-on seminar, it gives the reader a greater sense features are relied upon. That way you can digest each piece in the of accomplishment. context of your current knowledge before moving on. To accomplish this, I leave some C features in place for longer than I would prefer.6. Provide readers with a solid foundation so they can The benefit is that you will not be confused by seeing all the C++ understand the issues well enough to move on to more features used before they are explained, so your introduction to the difficult coursework and books (in particular, Volume 2 of language will be gentle and will mirror the way you will assimilate this book). the features if left to your own devices.6 Thinking in C++ www.BruceEckel.com Preface 7
  15. 15. Here is a brief description of the chapters contained in this book: by the simple act of putting functions inside structures, the details of how to do it, and what kind of code it creates. You’ll also learn theChapter 1: Introduction to Objects. When projects became too best way to organize your code into header files andbig and complicated to easily maintain, the “software crisis” was implementation files.born, with programmers saying, “We can’t get projects done, and ifwe can, they’re too expensive!” This precipitated a number of Chapter 5: Hiding the Implementation. You can decide thatresponses, which are discussed in this chapter along with the ideas some of the data and functions in your structure are unavailable toof object-oriented programming (OOP) and how it attempts to solve the user of the new type by making them private. This means thatthe software crisis. The chapter walks you through the basic you can separate the underlying implementation from the interfaceconcepts and features of OOP and also introduces the analysis and that the client programmer sees, and thus allow thatdesign process. In addition, you’ll learn about the benefits and implementation to be easily changed without affecting client code.concerns of adopting the language and suggestions for moving into The keyword class is also introduced as a fancier way to describe athe world of C++. new data type, and the meaning of the word “object” is demystified (it’s a fancy variable).Chapter 2: Making and Using Objects. This chapter explainsthe process of building programs using compilers and libraries. It Chapter 6: Initialization and Cleanup. One of the mostintroduces the first C++ program in the book and shows how common C errors results from uninitialized variables. Theprograms are constructed and compiled. Then some of the basic constructor in C++ allows you to guarantee that variables of yourlibraries of objects available in Standard C++ are introduced. By the new data type (“objects of your class”) will always be initializedtime you finish this chapter you’ll have a good grasp of what it properly. If your objects also require some sort of cleanup, you canmeans to write a C++ program using off-the-shelf object libraries. guarantee that this cleanup will always happen with the C++ destructor.Chapter 3: The C in C++. This chapter is a dense overview of thefeatures in C that are used in C++, as well as a number of basic Chapter 7: Function Overloading and Default Arguments.features that are available only in C++. It also introduces the C++ is intended to help you build big, complex projects. While“make” utility that’s common in the software development world doing this, you may bring in multiple libraries that use the sameand that is used to build all the examples in this book (the source function name, and you may also choose to use the same name withcode for the book, which is available at www.BruceEckel.com, different meanings within a single library. C++ makes this easy withcontains makefiles for each chapter). Chapter 3 assumes that you function overloading, which allows you to reuse the same functionhave a solid grounding in some procedural programming language name as long as the argument lists are different. Default argumentslike Pascal, C, or even some flavors of Basic (as long as you’ve allow you to call the same function in different ways bywritten plenty of code in that language, especially functions). If you automatically providing default values for some of your arguments.find this chapter a bit too much, you should first go through theThinking in C seminar on the CD that’s bound with this book (and Chapter 8: Constants. This chapter covers the const andalso available at www.BruceEckel.com). volatile keywords, which have additional meaning in C++, especially inside classes. You’ll learn what it means to apply constChapter 4: Data Abstraction. Most features in C++ revolve to a pointer definition. The chapter also shows how the meaning ofaround the ability to create new data types. Not only does this const varies when used inside and outside of classes and how toprovide superior code organization, but it lays the groundwork for create compile-time constants inside classes.more powerful OOP abilities. You’ll see how this idea is facilitated8 Thinking in C++ www.BruceEckel.com Preface 9
  16. 16. Chapter 9: Inline Functions. Preprocessor macros eliminate delete elegantly solve this problem by safely creating objects on thefunction call overhead, but the preprocessor also eliminates heap. You’ll also see how new and delete can be overloaded in avaluable C++ type checking. The inline function gives you all the variety of ways so you can control how storage is allocated andbenefits of a preprocessor macro plus all of the benefits of a real released.function call. This chapter thoroughly explores the implementationand use of inline functions. Chapter 14: Inheritance and Composition. Data abstraction allows you to create new types from scratch, but with compositionChapter 10: Name Control. Creating names is a fundamental and inheritance, you can create new types from existing types. Withactivity in programming, and when a project gets large, the number composition, you assemble a new type using other types as pieces,of names can be overwhelming. C++ allows you a great deal of and with inheritance, you create a more specific version of ancontrol over names in terms of their creation, visibility, placement existing type. In this chapter you’ll learn the syntax, how to redefineof storage, and linkage. This chapter shows how names are functions, and the importance of construction and destruction forcontrolled in C++ using two techniques. First, the static keyword is inheritance and composition.used to control visibility and linkage, and its special meaning withclasses is explored. A far more useful technique for controlling Chapter 15: Polymorphism and virtual Functions. On yournames at the global scope is C++’s namespace feature, which own, you might take nine months to discover and understand thisallows you to break up the global name space into distinct regions. cornerstone of OOP. Through small, simple examples, you’ll see how to create a family of types with inheritance and manipulateChapter 11: References and the Copy-Constructor. C++ objects in that family through their common base class. The virtualpointers work like C pointers with the additional benefit of stronger keyword allows you to treat all objects in this family generically,C++ type checking. C++ also provides an additional way to handle which means that the bulk of your code doesn’t rely on specific typeaddresses: from Algol and Pascal, C++ lifts the reference, which lets information. This makes your programs extensible, so buildingthe compiler handle the address manipulation while you use programs and code maintenance is easier and cheaper.ordinary notation. You’ll also meet the copy-constructor, whichcontrols the way objects are passed into and out of functions by Chapter 16: Introduction to Templates. Inheritance andvalue. Finally, the C++ pointer-to-member is illuminated. composition allow you to reuse object code, but that doesn’t solve all of your reuse needs. Templates allow you to reuse source code byChapter 12: Operator Overloading. This feature is sometimes providing the compiler with a way to substitute type names in thecalled “syntactic sugar;” it lets you sweeten the syntax for using body of a class or function. This supports the use of container classyour type by allowing operators as well as function calls. In this libraries, which are important tools for the rapid, robustchapter you’ll learn that operator overloading is just a different type development of object-oriented programs (the Standard C++of function call and you’ll learn how to write your own, dealing with Library includes a significant library of container classes). Thisthe sometimes-confusing uses of arguments, return types, and the chapter gives you a thorough grounding in this essential subject.decision of whether to make an operator a member or friend. Additional topics (and more advanced subjects) are available inChapter 13: Dynamic Object Creation. How many planes will Volume 2 of this book, which can be downloaded from the Web sitean air-traffic system need to manage? How many shapes will a CAD www.BruceEckel.com.system require? In the general programming problem, you can’tknow the quantity, lifetime, or type of objects needed by yourrunning program. In this chapter, you’ll learn how C++’s new and10 Thinking in C++ www.BruceEckel.com Preface 11
  17. 17. All rights reserved EXCEPT as allowed by theExercises following statements: You can freely use this file I’ve discovered that exercises are exceptionally useful during a for your own work (personal or commercial), seminar to complete a student’s understanding, so you’ll find a set including modifications and distribution in executable form only. Permission is granted to use at the end of each chapter. The number of exercises has been greatly this file in classroom situations, including its increased over the number in the first edition. use in presentation materials, as long as the book "Thinking in C++" is cited as the source. Many of the exercises are fairly simple so that they can be finished Except in classroom situations, you cannot copy in a reasonable amount of time in a classroom situation or lab and distribute this code; instead, the sole section while the instructor observes, making sure all students are distribution point is http://www.BruceEckel.com absorbing the material. Some exercises are a bit more challenging (and official mirror sites) where it is to keep advanced students entertained. The bulk of the exercises are available for free. You cannot remove this copyright and notice. You cannot distribute designed to be solved in a short time and are intended only to test modified versions of the source code in this and polish your knowledge rather than present major challenges package. You cannot use this file in printed (presumably, you’ll find those on your own – or more likely, they’ll media without the express permission of the find you). author. Bruce Eckel makes no representation about the suitability of this software for any purpose. It is provided "as is" without express or impliedExercise solutions warranty of any kind, including any implied Solutions to selected exercises can be found in the electronic warranty of merchantability, fitness for a document The Thinking in C++ Annotated Solution Guide, particular purpose, or non-infringement. The entire risk as to the quality and performance of the available for a small fee from www.BruceEckel.com. software is with you. Bruce Eckel and the publisher shall not be liable for any damages suffered by you or any third party as a result ofSource code using or distributing this software. In no event will Bruce Eckel or the publisher be liable for The source code for this book is copyrighted freeware, distributed any lost revenue, profit, or data, or for direct, via the Web site www.BruceEckel.com. The copyright prevents you indirect, special, consequential, incidental, or from republishing the code in print media without permission, but punitive damages, however caused and regardless of you are granted the right to use it in many other situations (see the theory of liability, arising out of the use of below). or inability to use software, even if Bruce Eckel and the publisher have been advised of the The code is available in a zipped file, designed to be extracted for possibility of such damages. Should the software prove defective, you assume the cost of all any platform that has a “zip” utility (most do; you can search the necessary servicing, repair, or correction. If you Internet to find a version for your platform if you don’t already have think youve found an error, please submit the one installed). In the starting directory where you unpacked the correction using the form you will find at code you will find the following copyright notice: www.BruceEckel.com. (Please use the same form for non-code errors found in the book.) //:! :Copyright.txt ///:~ Copyright (c) 2000, Bruce Eckel Source code file from the book "Thinking in C++" 12 Thinking in C++ www.BruceEckel.com Preface 13
  18. 18. You may use the code in your projects and in the classroom as long Thus, ‘ISO’ is the correct way to refer to the C++ Standard. as the copyright notice is retained. Language support Your compiler may not support all of the features discussed in thisLanguage standards book, especially if you don’t have the newest version of the Throughout this book, when referring to conformance to the ISO C compiler. Implementing a language like C++ is a Herculean task, standard, I will generally just say ‘C.’ Only if it is necessary to and you can expect that the features will appear in pieces rather distinguish between Standard C and older, pre-Standard versions of than all at once. But if you attempt one of the examples in the book C will I make a distinction. and get a lot of errors from the compiler, it’s not necessarily a bug in the code or the compiler; it may simply not be implemented in At this writing the C++ Standards Committee was finished working your particular compiler yet. on the language. Thus, I will use the term Standard C++ to refer to the standardized language. If I simply refer to C++ you should assume I mean “Standard C++.” The book’s CD ROM There is some confusion over the actual name of the C++ Standards The primary content of the CD ROM packaged in the back of this Committee and the name of the standard itself. Steve Clamage, the book is a “seminar on CD ROM” titled Thinking in C: Foundations committee chair, clarified this: for Java & C++ by Chuck Allison (published by MindView, Inc., and also available in quantities at www.BruceEckel.com). This There are two C++ standardization committees: The NCITS contains many hours of audio lectures and slides, and can be viewed (formerly X3) J16 committee and the ISO JTC1/SC22/WG14 on most computers if you have a CD ROM player and a sound committee. ANSI charters NCITS to create technical system. committees for developing American national standards. The goal of Thinking in C is to take you carefully through the J16 was chartered in 1989 to create an American standard for fundamentals of the C language. It focuses on the knowledge C++. In about 1991 WG14 was chartered to create an necessary for you to be able to move on to the C++ or Java international standard. The J16 project was converted to a languages instead of trying to make you an expert in all the dark "Type I" (International) project and subordinated to the ISO corners of C. (One of the reasons for using a higher-level language standardization effort. like C++ or Java is precisely so we can avoid many of these dark corners.) It also contains exercises and guided solutions. Keep in The two committees meet at the same time at the same location, mind that because Chapter 3 of this book goes beyond the Thinking and the J16 vote constitutes the American vote on WG14. WG14 in C CD, the CD is not a replacement for that chapter, but should be delegates technical work to J16. WG14 votes on the technical used instead as a preparation for this book. work of J16. Please note that the CD ROM is browser-based, so you should have The C++ standard was originally created as an ISO standard. a Web browser installed on your machine before using it. ANSI later voted (as recommended by J16) to adopt the ISO C++ standard as the American standard for C++. 14 Thinking in C++ www.BruceEckel.com Preface 15
  19. 19. CD ROMs, seminars, About the coverand consulting The first edition of this book had my face on the cover, but I originally wanted a cover for the second edition that was more of a There are seminars-on-CD-ROM planned to cover Volume 1 and work of art like the Thinking in Java cover. For some reason, C++ Volume 2 of this book. These comprise many hours of audio seems to me to suggest Art Deco with its simple curves and brushed lectures by me that accompany slides that cover selected material chrome. I had in mind something like those posters of ships and from each chapter in the book. They can be viewed on most airplanes with the long sweeping bodies. computers if you have a CD ROM player and a sound system. These CDs may be purchased at www.BruceEckel.com, where you will My friend Daniel Will-Harris, (www.Will-Harris.com) whom I first find more information and sample lectures. met in junior high school choir class, went on to become a world- class designer and writer. He has done virtually all of my designs, My company, MindView, Inc., provides public hands-on training including the cover for the first edition of this book. During the seminars based on the material in this book and also on advanced cover design process, Daniel, unsatisfied with the progress we were topics. Selected material from each chapter represents a lesson, making, kept asking “How does this relate people to computers?” which is followed by a monitored exercise period so each student We were stuck. receives personal attention. We also provide on-site training, consulting, mentoring, and design and code walkthroughs. On a whim, with no particular outcome in mind, he asked me to put Information and sign-up forms for upcoming seminars and other my face on the scanner. Daniel had one of his graphics programs contact information can be found at www.BruceEckel.com. (Corel Xara, his favorite) “autotrace” the scan of my face. As he describes it, “Autotracing is the computers way to turn a picture I am sometimes available for design consulting, project evaluation into the kinds of lines and curves it really likes.” Then he played and code walkthroughs. When I first began writing about with it until he had something that looked like a topographic map of computers, my primary motivation was to increase my consulting my face, an image that might be the way a computer could see activities, because I find consulting to be challenging, educational, people. and one of my most enjoyable experiences, professionally. Thus I will try my best to fit you into my schedule, or to provide you with I took this image and photocopied it onto watercolor paper (some one of my associates (who are people that I know well and trust, color copiers can handle thick stock), and then started creating lots and often people who co-develop and teach seminars with me). of experiments by adding watercolor to the image. We selected the ones we liked best, then Daniel scanned them back in and arranged them into the cover, adding the text and other design elements. TheErrors whole process happened over several months, mostly because of the No matter how many tricks a writer uses to detect errors, some time it took me to do the watercolors. But I’ve especially enjoyed it always creep in and these often leap off the page to a fresh reader. If because I got to participate in the art on the cover, and because it you discover anything you believe to be an error, please use the gave me incentive to do more watercolors (what they say about correction form you will find at www.BruceEckel.com. Your help is practice really is true). appreciated. 16 Thinking in C++ www.BruceEckel.com Preface 17
  20. 20. Book design and production Acknowledgements The book’s interior design was created by Daniel Will-Harris, who First, thanks to everyone on the Internet who submitted corrections used to play with rub-on letters in junior high school while he and suggestions; you’ve been tremendously helpful in improving awaited the invention of computers and desktop publishing. the quality of this book, and I couldn’t have done it without you. However, I produced the camera-ready pages myself, so the Special thanks to John Cook. typesetting errors are mine. Microsoft® Word for Windows Versions 8 and 9 were used to write the book and to create camera- The ideas and understanding in this book have come from many ready pages, including generating the table of contents and index. (I sources: friends like Chuck Allison, Andrea Provaglio, Dan Saks, created a COM automation server in Python, called from Word VBA Scott Meyers, Charles Petzold, and Michael Wilk; pioneers of the macros, to aid me in index marking.) Python (see language like Bjarne Stroustrup, Andrew Koenig, and Rob Murray; www.Python.org) was used to create some of the tools for checking members of the C++ Standards Committee like Nathan Myers (who the code, and would have been use for the code extraction tool had I was particularly helpful and generous with his insights), Bill discovered it earlier. Plauger, Reg Charney, Tom Penello, Tom Plum, Sam Druker, and Uwe Steinmueller; people who have spoken in my C++ track at the I created the diagrams using Visio® – thanks to Visio Corporation Software Development Conference; and often students in my for creating a useful tool. seminars, who ask the questions I need to hear in order to make the material more clear. The body typeface is Georgia and the headlines are in Verdana. The final camera-ready version was produced in Adobe® Acrobat 4 and A huge thank-you to my friend Gen Kiyooka, whose company taken directly to press from that file – thanks very much to Adobe Digigami has provided me with a web server. for creating a tool that allows e-mailing camera-ready documents, as it enables multiple revisions to be made in a single day rather My friend Richard Hale Shaw and I have taught C++ together; than relying on my laser printer and overnight express services. Richard’s insights and support have been very helpful (and Kim’s, (We first tried the Acrobat process with Thinking in Java, and I was too). Thanks also to KoAnn Vikoren, Eric Faurot, Jennifer Jessup, able to upload the final version of that book to the printer in the Tara Arrowood, Marco Pardi, Nicole Freeman, Barbara Hanscome, U.S. from South Africa.) Regina Ridley, Alex Dunne, and the rest of the cast and crew at MFI. The HTML version was created by exporting the Word document to RTF, then using RTF2HTML (see A special thanks to all my teachers and all my students (who are my http://www.sunpack.com/RTF/) to do most of the work of the teachers as well). HTML conversion. (Thanks to Chris Hector for making such a useful, and especially reliable, tool.) The resulting files were cleaned And for favorite writers, my deep appreciation and sympathy for up using a custom Python program that I hacked together, and the your efforts: John Irving, Neal Stephenson, Robertson Davies (we WMFs were converted to GIFs using JASC® PaintShop Pro 6 and its shall miss you), Tom Robbins, William Gibson, Richard Bach, batch conversion tool (thanks to JASC for solving so many Carlos Castaneda, and Gene Wolfe. problems for me with their excellent product). The color syntax highlighting was added via a Perl script kindly contributed by Zafir To Guido van Rossum, for inventing Python and giving it selflessly Anjum. to the world. You have enriched my life with your contribution. 18 Thinking in C++ www.BruceEckel.com Preface 19

×