1. Trang chủ
  2. » Công Nghệ Thông Tin

Exploring c++ 11, 2nd ed

617 88 0

Đang tải... (xem toàn văn)

Tài liệu hạn chế xem trước, để xem đầy đủ mời bạn chọn Tải xuống

THÔNG TIN TÀI LIỆU

Thông tin cơ bản

Định dạng
Số trang 617
Dung lượng 4,02 MB

Nội dung

www.allitebooks.com For your convenience Apress has placed some of the front matter material after the index Please use the Bookmarks and Contents at a Glance links to access them www.allitebooks.com Contents at a Glance About the Author������������������������������������������������������������������������������������������������������������� xxiii About the Technical Reviewers���������������������������������������������������������������������������������������� xxv Acknowledgments���������������������������������������������������������������������������������������������������������� xxvii Introduction��������������������������������������������������������������������������������������������������������������������� xxix ■■Exploration 1: Honing Your Tools���������������������������������������������������������������������������������������1 ■■Exploration 2: Reading C++ Code��������������������������������������������������������������������������������������9 ■■Exploration 3: Integer Expressions����������������������������������������������������������������������������������15 ■■Exploration 4: Strings������������������������������������������������������������������������������������������������������21 ■■Exploration 5: Simple Input���������������������������������������������������������������������������������������������27 ■■Exploration 6: Error Messages����������������������������������������������������������������������������������������33 ■■Exploration 7: For Loops��������������������������������������������������������������������������������������������������39 ■■Exploration 8: Formatted Output�������������������������������������������������������������������������������������43 ■■Exploration 9: Arrays and Vectors�����������������������������������������������������������������������������������51 ■■Exploration 10: Algorithms and Iterators������������������������������������������������������������������������55 ■■Exploration 11: Increment and Decrement����������������������������������������������������������������������61 ■■Exploration 12: Conditions and Logic������������������������������������������������������������������������������67 ■■Exploration 13: Compound Statements���������������������������������������������������������������������������75 ■■Exploration 14: Introduction to File I/O���������������������������������������������������������������������������85 ■■Exploration 15: The Map Data Structure�������������������������������������������������������������������������89 ■■Exploration 16: Type Synonyms���������������������������������������������������������������������������������������95 iii www.allitebooks.com ■ Contents at a Glance ■■Exploration 17: Characters����������������������������������������������������������������������������������������������99 ■■Exploration 18: Character Categories����������������������������������������������������������������������������105 ■■Exploration 19: Case-Folding����������������������������������������������������������������������������������������111 ■■Exploration 20: Writing Functions���������������������������������������������������������������������������������115 ■■Exploration 21: Function Arguments�����������������������������������������������������������������������������123 ■■Exploration 22: Using Algorithms����������������������������������������������������������������������������������131 ■■Exploration 23: Unnamed Functions������������������������������������������������������������������������������141 ■■Exploration 24: Overloading Function Names���������������������������������������������������������������149 ■■Exploration 25: Big and Little Numbers�������������������������������������������������������������������������155 ■■Exploration 26: Very Big and Very Little Numbers��������������������������������������������������������165 ■■Exploration 27: Documentation�������������������������������������������������������������������������������������173 ■■Exploration 28: Project 1: Body-Mass Index�����������������������������������������������������������������181 ■■Exploration 29: Custom Types���������������������������������������������������������������������������������������183 ■■Exploration 30: Overloading Operators�������������������������������������������������������������������������191 ■■Exploration 31: Custom I/O Operators���������������������������������������������������������������������������201 ■■Exploration 32: Assignment and Initialization��������������������������������������������������������������205 ■■Exploration 33: Writing Classes������������������������������������������������������������������������������������213 ■■Exploration 34: More About Member Functions������������������������������������������������������������221 ■■Exploration 35: Access Levels���������������������������������������������������������������������������������������229 ■■Exploration 36: Introduction to Object-Oriented Programming�������������������������������������239 ■■Exploration 37: Inheritance�������������������������������������������������������������������������������������������245 ■■Exploration 38: Virtual Functions����������������������������������������������������������������������������������255 ■■Exploration 39: Classes and Types��������������������������������������������������������������������������������263 ■■Exploration 40: Declarations and Definitions����������������������������������������������������������������273 ■■Exploration 41: Using Multiple Source Files������������������������������������������������������������������283 iv www.allitebooks.com ■ Contents at a Glance ■■Exploration 42: Function Objects�����������������������������������������������������������������������������������297 ■■Exploration 43: Useful Algorithms���������������������������������������������������������������������������������301 ■■Exploration 44: Iterators������������������������������������������������������������������������������������������������315 ■■Exploration 45: Exceptions��������������������������������������������������������������������������������������������325 ■■Exploration 46: More Operators������������������������������������������������������������������������������������339 ■■Exploration 47: Project 2: Fixed-Point Numbers�����������������������������������������������������������349 ■■Exploration 48: Function Templates������������������������������������������������������������������������������355 ■■Exploration 49: Class Templates������������������������������������������������������������������������������������365 ■■Exploration 50: Template Specialization�����������������������������������������������������������������������373 ■■Exploration 51: Partial Template Specialization������������������������������������������������������������381 ■■Exploration 52: Names and Namespaces����������������������������������������������������������������������387 ■■Exploration 53: Containers��������������������������������������������������������������������������������������������405 ■■Exploration 54: Locales and Facets�������������������������������������������������������������������������������425 ■■Exploration 55: International Characters����������������������������������������������������������������������437 ■■Exploration 56: Text I/O�������������������������������������������������������������������������������������������������445 ■■Exploration 57: Project 3: Currency Type����������������������������������������������������������������������459 ■■Exploration 58: Pointers������������������������������������������������������������������������������������������������461 ■■Exploration 59: Dynamic Memory���������������������������������������������������������������������������������475 ■■Exploration 60: Moving Data with Rvalue References���������������������������������������������������491 ■■Exploration 61: Exception-Safety����������������������������������������������������������������������������������499 ■■Exploration 62: Old-Fashioned Arrays���������������������������������������������������������������������������509 ■■Exploration 63: Smart Pointers�������������������������������������������������������������������������������������517 ■■Exploration 64: Working with Bits���������������������������������������������������������������������������������527 ■■Exploration 65: Enumerations���������������������������������������������������������������������������������������543 ■■Exploration 66: Multiple Inheritance�����������������������������������������������������������������������������551 v www.allitebooks.com ■ Contents at a Glance ■■Exploration 67: Traits and Policies��������������������������������������������������������������������������������563 ■■Exploration 68: Names, Namespaces, and Templates���������������������������������������������������577 ■■Exploration 69: Overloaded Functions and Operators���������������������������������������������������587 ■■Exploration 70: Metaprogramming��������������������������������������������������������������������������������599 ■■Exploration 71: Project 4: Calculator�����������������������������������������������������������������������������611 Index���������������������������������������������������������������������������������������������������������������������������������613 vi www.allitebooks.com Introduction Hi, there Thank you for reading my book Exploring C++ 11 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 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, 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 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 grading 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 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 demonstrably wrong answers I hope you wrote something similar to, “Completing every exercise” or “Understanding all the material.” Another good answer is, “Having fun.” xxix www.allitebooks.com ■ Introduction The Book’s Organization C++ is a complicated language To write even the most trivial program requires an understanding 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 expressions 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 practice 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 particular, you don’t need to know C, nor 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 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 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 language 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 languages, each with its own idioms and idiosyncrasies To become an effective C++ programmer, 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 the work on your own If you have questions, discuss 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 xxx www.allitebooks.com ■ Introduction Work on the projects together Maybe you can divide the work into two (or more) modules 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 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, http://cpphelp.com/exploring/ The web site has links to other books, other web sites, mailing 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, 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 students 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 information 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 information 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 successful Explorations work because • They force you to participate actively in the learning process It’s 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 • They are small, so your model grows in easy steps If 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 • They build on what you know I don’t toss out new concepts with the vain hope that you will automatically grasp them Instead, I tie new concepts to old ones I my best to ensure that every concept has a strong anchor in your existing mental model • They help you learn by doing Instead of spending the better part of a chapter reading 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 xxxi www.allitebooks.com ■ Introduction C++ is a complicated language, and learning C++ is not easy In any group of C++ programmers, 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 fundamental 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 important, so that you can continue to learn and enjoy C++ for many years to come The C++ Standard This book covers the current standard, namely, ISO/IEC 14882:2011 (E), Programming languages—C++ The 2011 edition of the standard is the all-new, improved standard, typically referred to as C++ 11 This book reflects new idioms, new language patterns, and new code All the exercises have been tested on modern compilers Most modern compilers a decent job of conforming to the standard, although some fall down in key areas The book’s web site will have up-to-date details as vendors release updates to their compilers If you are stuck using C++ 03, I recommend using the first edition of this book Although I occasionally mention which features are new to C++ 11, in general, I not try to help C++ 03 users, and sometimes I completely avoid C++ 03 best practices, because they have been replaced by even better C++ 11 practices xxxii www.allitebooks.com ■ Contents ■■Exploration 27: Documentation�������������������������������������������������������������������������������������173 Doxygen������������������������������������������������������������������������������������������������������������������������������������173 Structured Comments���������������������������������������������������������������������������������������������������������������173 Documentation Tags and Markdown�����������������������������������������������������������������������������������������174 Using Doxygen���������������������������������������������������������������������������������������������������������������������������179 ■■Exploration 28: Project 1: Body-Mass Index�����������������������������������������������������������������181 Hints������������������������������������������������������������������������������������������������������������������������������������������182 ■■Exploration 29: Custom Types���������������������������������������������������������������������������������������183 Defining a New Type������������������������������������������������������������������������������������������������������������������183 Member Functions��������������������������������������������������������������������������������������������������������������������184 Constructors������������������������������������������������������������������������������������������������������������������������������187 Overloading Constructors����������������������������������������������������������������������������������������������������������189 ■■Exploration 30: Overloading Operators�������������������������������������������������������������������������191 Comparing Rational Numbers���������������������������������������������������������������������������������������������������191 Arithmetic Operators�����������������������������������������������������������������������������������������������������������������194 Math Functions��������������������������������������������������������������������������������������������������������������������������197 ■■Exploration 31: Custom I/O Operators���������������������������������������������������������������������������201 Input Operator���������������������������������������������������������������������������������������������������������������������������201 Output Operator�������������������������������������������������������������������������������������������������������������������������202 Error State���������������������������������������������������������������������������������������������������������������������������������203 ■■Exploration 32: Assignment and Initialization��������������������������������������������������������������205 Assignment Operator�����������������������������������������������������������������������������������������������������������������205 Constructors������������������������������������������������������������������������������������������������������������������������������206 Putting It All Together����������������������������������������������������������������������������������������������������������������207 ■■Exploration 33: Writing Classes������������������������������������������������������������������������������������213 Anatomy of a Class��������������������������������������������������������������������������������������������������������������������213 Member Functions��������������������������������������������������������������������������������������������������������������������214 xii ■ Contents Constructor��������������������������������������������������������������������������������������������������������������������������������216 Defaulted and Deleted Constructors�����������������������������������������������������������������������������������������220 ■■Exploration 34: More About Member Functions������������������������������������������������������������221 Revisiting Project 1�������������������������������������������������������������������������������������������������������������������221 Const Member Functions����������������������������������������������������������������������������������������������������������225 ■■Exploration 35: Access Levels���������������������������������������������������������������������������������������229 Public vs Private�����������������������������������������������������������������������������������������������������������������������229 class vs struct��������������������������������������������������������������������������������������������������������������������������232 Plain Old Data����������������������������������������������������������������������������������������������������������������������������232 Public or Private?����������������������������������������������������������������������������������������������������������������������233 ■■Exploration 36: Introduction to Object-Oriented Programming�������������������������������������239 Books and Magazines���������������������������������������������������������������������������������������������������������������239 Classification�����������������������������������������������������������������������������������������������������������������������������240 Inheritance��������������������������������������������������������������������������������������������������������������������������������242 Liskov’s Substitution Principle��������������������������������������������������������������������������������������������������243 Type Polymorphism�������������������������������������������������������������������������������������������������������������������244 ■■Exploration 37: Inheritance�������������������������������������������������������������������������������������������245 Deriving a Class�������������������������������������������������������������������������������������������������������������������������245 Member Functions��������������������������������������������������������������������������������������������������������������������248 Destructors��������������������������������������������������������������������������������������������������������������������������������248 Access Level�����������������������������������������������������������������������������������������������������������������������������252 Programming Style��������������������������������������������������������������������������������������������������������������������253 ■■Exploration 38: Virtual Functions����������������������������������������������������������������������������������255 Type Polymorphism�������������������������������������������������������������������������������������������������������������������255 Virtual Functions�����������������������������������������������������������������������������������������������������������������������258 References and Slices���������������������������������������������������������������������������������������������������������������261 Pure Virtual Functions���������������������������������������������������������������������������������������������������������������262 Virtual Destructors��������������������������������������������������������������������������������������������������������������������262 xiii ■ Contents ■■Exploration 39: Classes and Types��������������������������������������������������������������������������������263 Classes vs typedefs������������������������������������������������������������������������������������������������������������������263 Value Types��������������������������������������������������������������������������������������������������������������������������������266 Copying�������������������������������������������������������������������������������������������������������������������������������������������������������������� 266 Assigning����������������������������������������������������������������������������������������������������������������������������������������������������������� 266 Moving��������������������������������������������������������������������������������������������������������������������������������������������������������������� 267 Comparing��������������������������������������������������������������������������������������������������������������������������������������������������������� 268 Resource Acquisition Is Initialization�����������������������������������������������������������������������������������������271 ■■Exploration 40: Declarations and Definitions����������������������������������������������������������������273 Declaration vs Definition����������������������������������������������������������������������������������������������������������273 inline Functions�������������������������������������������������������������������������������������������������������������������������275 Variable Declarations and Definitions���������������������������������������������������������������������������������������276 Static Variables��������������������������������������������������������������������������������������������������������������������������278 Static Data Members�����������������������������������������������������������������������������������������������������������������280 Declarators��������������������������������������������������������������������������������������������������������������������������������282 ■■Exploration 41: Using Multiple Source Files������������������������������������������������������������������283 Multiple Source Files�����������������������������������������������������������������������������������������������������������������283 Declarations and Definitions�����������������������������������������������������������������������������������������������������284 #include Files����������������������������������������������������������������������������������������������������������������������������287 Quotes and Brackets����������������������������������������������������������������������������������������������������������������������������������������� 288 Nested #include Directives�������������������������������������������������������������������������������������������������������������������������������� 288 Include Guards��������������������������������������������������������������������������������������������������������������������������������������������������� 289 Forward Declarations���������������������������������������������������������������������������������������������������������������������������������������� 291 Documentation�������������������������������������������������������������������������������������������������������������������������������������������������� 291 extern Variables�������������������������������������������������������������������������������������������������������������������������293 inline Functions�������������������������������������������������������������������������������������������������������������������������294 One-Definition Rule�������������������������������������������������������������������������������������������������������������������295 xiv ■ Contents ■■Exploration 42: Function Objects�����������������������������������������������������������������������������������297 The Function Call Operator��������������������������������������������������������������������������������������������������������297 Function Objects�����������������������������������������������������������������������������������������������������������������������299 ■■Exploration 43: Useful Algorithms���������������������������������������������������������������������������������301 Searching����������������������������������������������������������������������������������������������������������������������������������301 Linear Search Algorithms���������������������������������������������������������������������������������������������������������������������������������� 301 Binary Search Algorithms���������������������������������������������������������������������������������������������������������������������������������� 306 Comparing���������������������������������������������������������������������������������������������������������������������������������309 Rearranging Data����������������������������������������������������������������������������������������������������������������������311 Copying Data�����������������������������������������������������������������������������������������������������������������������������313 Deleting Elements���������������������������������������������������������������������������������������������������������������������313 Iterators�������������������������������������������������������������������������������������������������������������������������������������314 ■■Exploration 44: Iterators������������������������������������������������������������������������������������������������315 Kinds of Iterators�����������������������������������������������������������������������������������������������������������������������315 Input Iterators���������������������������������������������������������������������������������������������������������������������������������������������������� 316 Output Iterators������������������������������������������������������������������������������������������������������������������������������������������������� 316 Forward Iterators����������������������������������������������������������������������������������������������������������������������������������������������� 316 Bidirectional Iterators���������������������������������������������������������������������������������������������������������������������������������������� 316 Random Access Iterators����������������������������������������������������������������������������������������������������������������������������������� 317 Working with Iterators���������������������������������������������������������������������������������������������������������������318 const_iterator vs const iterator������������������������������������������������������������������������������������������������319 Error Messages�������������������������������������������������������������������������������������������������������������������������321 Specialized Iterators������������������������������������������������������������������������������������������������������������������322 ■■Exploration 45: Exceptions��������������������������������������������������������������������������������������������325 Introducing Exceptions��������������������������������������������������������������������������������������������������������������325 Catching Exceptions������������������������������������������������������������������������������������������������������������������327 Throwing Exceptions�����������������������������������������������������������������������������������������������������������������328 xv ■ Contents Program Stack���������������������������������������������������������������������������������������������������������������������������329 Standard Exceptions�����������������������������������������������������������������������������������������������������������������333 I/O Exceptions���������������������������������������������������������������������������������������������������������������������������334 Custom Exceptions��������������������������������������������������������������������������������������������������������������������335 Don’t Throw Exceptions�������������������������������������������������������������������������������������������������������������337 Exceptional Advice��������������������������������������������������������������������������������������������������������������������338 ■■Exploration 46: More Operators������������������������������������������������������������������������������������339 Conditional Operator�����������������������������������������������������������������������������������������������������������������339 Short-Circuit Operators�������������������������������������������������������������������������������������������������������������341 Comma Operator�����������������������������������������������������������������������������������������������������������������������341 Arithmetic Assignment Operators���������������������������������������������������������������������������������������������344 Increment and Decrement���������������������������������������������������������������������������������������������������������345 ■■Exploration 47: Project 2: Fixed-Point Numbers�����������������������������������������������������������349 value_type���������������������������������������������������������������������������������������������������������������������������������349 places����������������������������������������������������������������������������������������������������������������������������������������349 places10������������������������������������������������������������������������������������������������������������������������������������349 fixed( )����������������������������������������������������������������������������������������������������������������������������������������349 fixed(value_type integer, value_type fraction)��������������������������������������������������������������������������349 fixed(double val)������������������������������������������������������������������������������������������������������������������������350 to_string( )���������������������������������������������������������������������������������������������������������������������������������350 round( )��������������������������������������������������������������������������������������������������������������������������������������350 integer( )������������������������������������������������������������������������������������������������������������������������������������350 fraction( )�����������������������������������������������������������������������������������������������������������������������������������350 ■■Exploration 48: Function Templates������������������������������������������������������������������������������355 Generic Functions���������������������������������������������������������������������������������������������������������������������355 Using Function Templates���������������������������������������������������������������������������������������������������������356 Writing Function Templates�������������������������������������������������������������������������������������������������������357 Template Parameters����������������������������������������������������������������������������������������������������������������359 xvi ■ Contents Template Arguments�����������������������������������������������������������������������������������������������������������������360 Declarations and Definitions�����������������������������������������������������������������������������������������������������362 Member Function Templates�����������������������������������������������������������������������������������������������������362 ■■Exploration 49: Class Templates������������������������������������������������������������������������������������365 Parameterizing a Type���������������������������������������������������������������������������������������������������������������365 Parameterizing the rational Class���������������������������������������������������������������������������������������������366 Using Class Templates��������������������������������������������������������������������������������������������������������������368 Overloaded Operators����������������������������������������������������������������������������������������������������������������369 Mixing Types������������������������������������������������������������������������������������������������������������������������������371 ■■Exploration 50: Template Specialization�����������������������������������������������������������������������373 Instantiation and Specialization������������������������������������������������������������������������������������������������373 Custom Comparators�����������������������������������������������������������������������������������������������������������������376 Specializing Function Templates�����������������������������������������������������������������������������������������������377 Traits������������������������������������������������������������������������������������������������������������������������������������������378 ■■Exploration 51: Partial Template Specialization������������������������������������������������������������381 Degenerate Pairs�����������������������������������������������������������������������������������������������������������������������381 Partial Specialization�����������������������������������������������������������������������������������������������������������������382 Partially Specializing Function Templates���������������������������������������������������������������������������������383 Value Template Parameters�������������������������������������������������������������������������������������������������������383 ■■Exploration 52: Names and Namespaces����������������������������������������������������������������������387 Namespaces������������������������������������������������������������������������������������������������������������������������������387 Nested Namespaces�����������������������������������������������������������������������������������������������������������������390 Global Namespace��������������������������������������������������������������������������������������������������������������������392 The std Namespace�������������������������������������������������������������������������������������������������������������������392 Using Namespaces��������������������������������������������������������������������������������������������������������������������393 The using Directive�������������������������������������������������������������������������������������������������������������������������������������������� 393 The using Declaration���������������������������������������������������������������������������������������������������������������������������������������� 395 The using Declaration in a Class����������������������������������������������������������������������������������������������������������������������� 398 xvii ■ Contents Unnamed Namespaces�������������������������������������������������������������������������������������������������������������399 Name Lookup����������������������������������������������������������������������������������������������������������������������������399 ■■Exploration 53: Containers��������������������������������������������������������������������������������������������405 Properties of Containers������������������������������������������������������������������������������������������������������������405 Member Types���������������������������������������������������������������������������������������������������������������������������406 What Can Go into a Container���������������������������������������������������������������������������������������������������407 Inserting and Erasing����������������������������������������������������������������������������������������������������������������408 Inserting in a Sequence Container�������������������������������������������������������������������������������������������������������������������� 408 Erasing from a Sequence Container������������������������������������������������������������������������������������������������������������������ 409 Inserting in an Associative Container���������������������������������������������������������������������������������������������������������������� 410 Erasing from an Associative Container�������������������������������������������������������������������������������������������������������������� 411 Exceptions��������������������������������������������������������������������������������������������������������������������������������������������������������� 411 Iterators and References�����������������������������������������������������������������������������������������������������������412 Sequence Containers����������������������������������������������������������������������������������������������������������������414 The array Class Template���������������������������������������������������������������������������������������������������������������������������������� 416 The deque Class Template��������������������������������������������������������������������������������������������������������������������������������� 417 The list Class Template�������������������������������������������������������������������������������������������������������������������������������������� 417 The vector Class Template��������������������������������������������������������������������������������������������������������������������������������� 418 Associative Containers��������������������������������������������������������������������������������������������������������������419 ■■Exploration 54: Locales and Facets�������������������������������������������������������������������������������425 The Problem������������������������������������������������������������������������������������������������������������������������������425 Locales to the Rescue���������������������������������������������������������������������������������������������������������������426 Locales and I/O��������������������������������������������������������������������������������������������������������������������������427 Facets����������������������������������������������������������������������������������������������������������������������������������������427 Character Categories�����������������������������������������������������������������������������������������������������������������429 Collation Order��������������������������������������������������������������������������������������������������������������������������434 ■■Exploration 55: International Characters����������������������������������������������������������������������437 Why Wide?���������������������������������������������������������������������������������������������������������������������������������437 Using Wide Characters��������������������������������������������������������������������������������������������������������������437 xviii ■ Contents Wide Strings������������������������������������������������������������������������������������������������������������������������������438 Wide Character I/O��������������������������������������������������������������������������������������������������������������������440 Multi-Byte Character Sets���������������������������������������������������������������������������������������������������������441 Unicode�������������������������������������������������������������������������������������������������������������������������������������442 Universal Character Names�������������������������������������������������������������������������������������������������������443 Unicode Difficulties�������������������������������������������������������������������������������������������������������������������444 ■■Exploration 56: Text I/O�������������������������������������������������������������������������������������������������445 File Modes���������������������������������������������������������������������������������������������������������������������������������445 String Streams��������������������������������������������������������������������������������������������������������������������������446 Text Conversion�������������������������������������������������������������������������������������������������������������������������452 ■■Exploration 57: Project 3: Currency Type����������������������������������������������������������������������459 ■■Exploration 58: Pointers������������������������������������������������������������������������������������������������461 A Programming Problem�����������������������������������������������������������������������������������������������������������461 The Solution������������������������������������������������������������������������������������������������������������������������������469 Addresses vs Pointers��������������������������������������������������������������������������������������������������������������470 Dependency Graphs������������������������������������������������������������������������������������������������������������������471 ■■Exploration 59: Dynamic Memory���������������������������������������������������������������������������������475 Allocating Memory��������������������������������������������������������������������������������������������������������������������475 Freeing Memory������������������������������������������������������������������������������������������������������������������������476 Pointer to Nothing���������������������������������������������������������������������������������������������������������������������476 Implementing Standard Containers�������������������������������������������������������������������������������������������478 Adding Variables������������������������������������������������������������������������������������������������������������������������479 Special Member Functions��������������������������������������������������������������������������������������������������������486 ■■Exploration 60: Moving Data with Rvalue References���������������������������������������������������491 Temporary Objects��������������������������������������������������������������������������������������������������������������������491 Lvalues, Rvalues, and More�������������������������������������������������������������������������������������������������������494 Implementing Move�������������������������������������������������������������������������������������������������������������������495 xix ■ Contents Rvalue or Lvalue?����������������������������������������������������������������������������������������������������������������������496 Special Member Functions��������������������������������������������������������������������������������������������������������497 ■■Exploration 61: Exception-Safety����������������������������������������������������������������������������������499 Memory Leaks���������������������������������������������������������������������������������������������������������������������������499 Exceptions and Dynamic Memory���������������������������������������������������������������������������������������������501 Automatically Deleting Pointers������������������������������������������������������������������������������������������������502 Exceptions and Constructors�����������������������������������������������������������������������������������������������������505 ■■Exploration 62: Old-Fashioned Arrays���������������������������������������������������������������������������509 C-Style Arrays����������������������������������������������������������������������������������������������������������������������������509 Array Limitations�����������������������������������������������������������������������������������������������������������������������510 Dynamically Allocating an Array������������������������������������������������������������������������������������������������511 The array Type���������������������������������������������������������������������������������������������������������������������������512 Multidimensional Arrays������������������������������������������������������������������������������������������������������������512 C-Style Strings��������������������������������������������������������������������������������������������������������������������������513 Command-Line Arguments��������������������������������������������������������������������������������������������������������513 Pointer Arithmetic����������������������������������������������������������������������������������������������������������������������515 ■■Exploration 63: Smart Pointers�������������������������������������������������������������������������������������517 Revisiting unique_ptr����������������������������������������������������������������������������������������������������������������517 Copyable Smart Pointers�����������������������������������������������������������������������������������������������������������518 Smart Arrays�����������������������������������������������������������������������������������������������������������������������������519 Pimpls���������������������������������������������������������������������������������������������������������������������������������������520 Iterators�������������������������������������������������������������������������������������������������������������������������������������525 ■■Exploration 64: Working with Bits���������������������������������������������������������������������������������527 Integer As a Set of Bits��������������������������������������������������������������������������������������������������������������527 Bitmasks�����������������������������������������������������������������������������������������������������������������������������������529 Shifting Bits�������������������������������������������������������������������������������������������������������������������������������530 xx ■ Contents Safe Shifting with Unsigned Types��������������������������������������������������������������������������������������������531 Signed and Unsigned Types������������������������������������������������������������������������������������������������������������������������������� 532 Unsigned Literals����������������������������������������������������������������������������������������������������������������������������������������������� 533 Type Conversions����������������������������������������������������������������������������������������������������������������������������������������������� 533 Overflow������������������������������������������������������������������������������������������������������������������������������������537 Introducing Bitfields������������������������������������������������������������������������������������������������������������������538 Portability����������������������������������������������������������������������������������������������������������������������������������539 The bitset Class Template���������������������������������������������������������������������������������������������������������539 ■■Exploration 65: Enumerations���������������������������������������������������������������������������������������543 Scoped Enumerations���������������������������������������������������������������������������������������������������������������543 Unscoped Enumerations�����������������������������������������������������������������������������������������������������������545 Strings and Enumerations���������������������������������������������������������������������������������������������������������545 Revisiting Projects���������������������������������������������������������������������������������������������������������������������547 ■■Exploration 66: Multiple Inheritance�����������������������������������������������������������������������������551 Multiple Base Classes���������������������������������������������������������������������������������������������������������������551 Virtual Base Classes������������������������������������������������������������������������������������������������������������������554 Java-Like Interfaces������������������������������������������������������������������������������������������������������������������556 Interfaces vs Templates�����������������������������������������������������������������������������������������������������������558 Mix-Ins��������������������������������������������������������������������������������������������������������������������������������������560 Protected Access Level�������������������������������������������������������������������������������������������������������������������������������������� 561 ■■Exploration 67: Traits and Policies��������������������������������������������������������������������������������563 Case Study: Iterators�����������������������������������������������������������������������������������������������������������������563 Iterator Traits�����������������������������������������������������������������������������������������������������������������������������566 Type Traits���������������������������������������������������������������������������������������������������������������������������������567 Case Study: char_traits�������������������������������������������������������������������������������������������������������������567 Policy-Based Programming�������������������������������������������������������������������������������������������������������569 xxi ■ Contents ■■Exploration 68: Names, Namespaces, and Templates���������������������������������������������������577 Common Rules��������������������������������������������������������������������������������������������������������������������������577 Name Lookup in Templates�������������������������������������������������������������������������������������������������������578 Three Kinds of Name Lookup����������������������������������������������������������������������������������������������������578 Member Access Operators��������������������������������������������������������������������������������������������������������578 Qualified Name Lookup�������������������������������������������������������������������������������������������������������������580 Unqualified Name Lookup���������������������������������������������������������������������������������������������������������582 Argument-Dependent Lookup���������������������������������������������������������������������������������������������������583 ■■Exploration 69: Overloaded Functions and Operators���������������������������������������������������587 Type Conversion������������������������������������������������������������������������������������������������������������������������587 Review of Overloaded Functions�����������������������������������������������������������������������������������������������588 Overload Resolution������������������������������������������������������������������������������������������������������������������591 Ranking Functions��������������������������������������������������������������������������������������������������������������������������������������������� 591 List Initialization������������������������������������������������������������������������������������������������������������������������������������������������ 593 Tie-Breakers������������������������������������������������������������������������������������������������������������������������������������������������������ 593 Default Arguments���������������������������������������������������������������������������������������������������������������������597 ■■Exploration 70: Metaprogramming��������������������������������������������������������������������������������599 Use constexpr for Compile-Time Values������������������������������������������������������������������������������������599 Variable-Length Template Argument Lists���������������������������������������������������������������������������������601 Types as Values�������������������������������������������������������������������������������������������������������������������������604 Conditional Types����������������������������������������������������������������������������������������������������������������������606 Checking Traits��������������������������������������������������������������������������������������������������������������������������607 Substitution Failure Is Not An Error (SFINAE)����������������������������������������������������������������������������609 ■■Exploration 71: Project 4: Calculator�����������������������������������������������������������������������������611 Index���������������������������������������������������������������������������������������������������������������������������������613 xxii About the Author All the world is paged, And all the men and women merely programs: They have their exits and their segfaults; And one man in his time plays many games, His acts being seven ages At first, the newbie, Mewling and puking in BASIC terms And then the whining school-boy, with his packages, And JavaServer Faces, creeping like snail Downloading from the Web And then the l0v3r, Sighing like heat sink fan, with an unmerged commit Made to his github project Then a hacker, Full of strange oaths and bearded like a guru, Jealous in honor, sudden and quick in quarrel, Seeking the flamebait reputation Even on lkml And then the justice, In fair round belly with cappuccino drowned, With eyes severe and beard of two days’ cut, Full of wise saws and modern design patterns; And so he plays his part The sixth age shifts Into the lean and sandal’d pantaloon, With bifocals on nose and balding pate, His COBOL code, well saved, a world too wide For his shrunk shank; and his big noisy voice, Turning again toward childish errors, buffer Overruns in his code Last scene of all, That ends this strange eventful history, Is second childishness and mere oblivion, xxiii ■ About the Author Sans mouse, sans keyboard, sans debugger, sans everything By William Shakespeare, edited by Ray Lischner Ray Lischner started writing programs before he had access to a computer, and over the subsequent three decades, he progressed steadily through the ages of programming He currently lives with his wife, children, and four-terabyte MythTV server in Maryland, where he does his best to retard the inexorable descent into the seventh age xxiv About the Technical Reviewers Fabio Claudio Ferracchiati is a senior consultant and a senior analyst/developer using Microsoft technologies He works for Brain Force (www.brainforce.com) in its Italian branch (www.brainforce.it) He is a Microsoft Certified Solution Developer for NET, a Microsoft Certified Application Developer for NET, a Microsoft Certified Professional, and a prolific author and technical reviewer Over the past ten years, he’s written articles for Italian and international magazines and coauthored more than ten books on a variety of computer topics Stefan Turalski is just another coder, who is trying to optimize his small world full of libraries, servers, tests, config files, and the like a line of code at a time Wearing many hats, with well over a decade of experience in software development, he specializes in implementation, design, and team management He has built a wide range of systems, from embedded networking, health care, and low-latency trading to highly scalable, distributed C++ / Java / NET enterprise-class solutions Stefan is currently working at a financial institution in London xxv Acknowledgments As with any book, many hardworking folk contributed to the product you hold in your hands (or read online) I thank the technical reviewers, Stefan Turalski and Fabio Claudio Ferracchiati, for their many corrections, suggestions, and comments I thank the Apress editors and staff, without whom this book would be no more than bits on my file server: Ewan Buckingham, Katie Sullivan, Christine Ricketts, and Michael G Laraque Most of all, I thank my wife, Cheryl, and my children for their patience with my repeated absence on evenings and weekends Finally, I thank my readers, for they are the most important people in the publishing business xxvii ... OLD-FASHIONED INITIALIZATION The brace style of initializing all variables was introduced in C++ 11, so code that predates C++ 11 (or new code that was written by programmers who learned C++ prior to C++. .. Standard C++ Compiler Options Visual C++ command line /EHsc /Za Visual C++ IDE Enable C++ exceptions, disable language extensions g++ -pedantic -std =c++1 1 clang/llvm -pedantic -std =c++1 1 Your... C++, not C++/ CLI or Managed C++ (the predecessor to C++/ CLI) Visual Studio includes a number of doodads, froufrous, and whatnots that are unimportant for your core task of learning C++ Perhaps

Ngày đăng: 12/10/2020, 17:42

w