ebook img

Exploring C++ 11: Learn C++ with Practical Hands-On Exercises PDF

617 Pages·3.983 MB·English
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Exploring C++ 11: Learn C++ with Practical Hands-On Exercises

BOOKS FOR PROFESSIONALS BY PROFESSIONALS® Lischner Exploring C++ 11 RELATED Exploring C++ 11 uses a series of self–directed lessons to divide C++ into bite–sized chunks that you can digest as rapidly as you can swallow them. The book assumes only a basic understanding of fundamental programming concepts (variables, functions, expressions, statements) and requires no prior knowledge of C or any other particular language. It reduces the usually considerable complexity of C++. The included lessons allow you to learn by doing, as a participant of an interactive education session. You’ll master each step in one sitting before you proceed to the next. Author Ray Lischner has designed questions to promote learning new material. And by responding to questions throughout the text, you’ll be engaged every step of the way. What you’ll learn: • To develop websites quickly using Textpattern’s intuitive templating language • To use Textpattern to build e-commerce websites, including customer feedback and reviews • To use Textpattern and web standards to create blogs and community sites with dynamically driven content • To integrate your own style of coding and design with a content management system that catalyses, rather than hinders, your creativity • To use PHP to create Textpattern plugins, adding custom functionality and features to uniquely suit the needs of your website Shelve in ISBN 978-1-4302-6193-3 SECOND Programming Languages/C++ 55999 User level: EDITION Beginning–Advanced SOURCE CODE ONLINE 9 781430 261933 www.apress.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. 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 ■ 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 ■ 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 ■ 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 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 do that, I have written a series of lessons called Explorations. Each Exploration is an interactive exercise that helps you learn C++ one step at a time. Your job is to complete the Explorations and, in so doing, learn C++. No doubt you have already leafed through the book a little bit. If not, do so now. Notice that this book is different from most books. Most programming books are little more than written lectures. The author tells you stuff and expects you to read the stuff, learn it, and understand it. This book is different. I don’t see much point in lecturing at you. That’s not how people learn best. You learn programming by reading, modifying, and writing programs. To that end, I’ve organized this book so that you spend as much time as possible reading, modifying, and writing programs. How to Use This Book Each exploration in this book is a mixture of text and interactive exercises. The exercises are unlike anything you’ve seen in other books. Instead of multiple-choice, fill-in-the-blank, or simple Q&A exercises, my lessons are interactive explorations of key C++ features. Early in the book, I will give you complete programs to work with. As you learn more C++, you will modify and extend programs. Pretty soon, you will write entire programs on your own. By interactive, I mean that I ask questions and you answer them. I do my best to respond to your answers throughout the lesson text. It sounds crazy, but by answering the questions, you will be learning C++. To help ensure you answer the questions, I leave space in this book for you to write your answers. I’m giving you permission to write in this book (unless you are borrowing the book from a library or friend). In fact, I encourage you to write all your answers in the book. Only by answering the questions will you learn the material properly. Sometimes, the questions have no right answer. I pose the question to make you ponder it, perhaps to look at a familiar topic from a new perspective. Other times, the question has an unambiguous, correct answer. I always give the answer in the subsequent text, so don’t skip ahead! Write your answer before you continue reading. Then and only then can you check your answer. Some questions are tricky or require information that I have not yet presented. In such cases, I expect your answer to be wrong, but that’s okay. Don’t worry. I won’t be 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 ■ 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 do you need to know anything about object-oriented programming. The C programming language influenced the design of many other languages, from PHP to Perl to AWK to C#, not to mention C++. As a result, many programmers who do not know C or C++ nonetheless find many language constructs hauntingly familiar. You might even feel confident enough to skip sections of this book that seem to cover old ground. Don’t do that! From the start, the lessons present language features that are unique to C++. In a few, isolated cases, I will tell you when it is safe to skip a section, and only that section. Even when a 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 do 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 ■ 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 do everything. For More Information This book cannot teach you everything you need to know about C++. No single book can. After you finish this book, I encourage you to continue to read and write C++ programs and to seek out other sources of information. To help guide you, this book has a dedicated web site, 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 do 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 ■ 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 do 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 do 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

See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.