C++ For Dummies®, 5th Edition

If you’ve thought of programmers as elite intelligentsia who possess expertise (and perhaps genes) the rest of us will never have, think again. C++ For Dummies, 5th Edition, debunks the myths, blasts the barriers, shares the secrets, and gets you started. In fact, by the end of Chapter 1, you’ll be able to create a C++ program. OK, it won’t be newest, flashiest video game, but it might be a practical, customized inventory control or record-keeping program. Most people catch on faster when they actually DO something, so C++ For Dummies includes a CD-ROM that gives you all you need to start programming (except the guidance in the book, of course), including: Dev-C, a full-featured, integrated C++ compiler and editor you install to get down to business The source code for the programs in the book, including code for BUDGET, programs that demonstrate principles in the book Documentation for the Standard Template Library Online C++ help files Written by Stephen Randy Davis, author of C++ Weekend Crash Course, C++ for Dummies, takes you through the programming process step-by-step. You’ll discover how to: Generate an executable Create source code, commenting it as you go and using consistent code indentation and naming conventions Write declarations and name variables, and calculate expressions Write and use a function, store sequences in arrays, and declare and use pointer variables Understand classes and object-oriented programming Work with constructors and destructors Use inheritance to extend classes Use stream I/O Comment your code as you go, and use consistent code indentation and naming conventions Automate programming with the Standard Template Library (STL) C++ for Dummies 5th Edition is updated for the newest ANSI standard to make sure you’re up to code. Note: CD-ROM/DVD and other supplementary materials are not included as part of eBook file. C++ for Dummies Cover Table of Contents Introduction What's in This Book What's on the CD What Is C++? Conventions Used in This Book How This Book Is Organized And There's More Part I: Introduction to C++ Programming Part II: Becoming a Functional C++ Programmer Part III: Introduction to Classes Part IV: Inheritance Part V: Optional Features Part VI: The Part of Tens Icons Used in This Book Where to Go from Here Part I: Introduction to C++ Programming Chapter 1: Writing Your First C++ Program Grasping C++ Concepts What's a program? How do I program? Installing Dev-C++ Setting the options Creating Your First C++ Program Entering the C++ code Building your program Executing Your Program Dev-C++ is not Windows Dev-C++ help Reviewing the Annotated Program Examining the framework for all C++ programs Clarifying source code with comments Basing programs on C++ statements Writing declarations Generating output Calculating Expressions Storing the results of expression Examining the remainder of Conversion.cpp Chapter 2: Declaring Variables Constantly Declaring Variables Declaring Different Types of Variables Reviewing the limitations of integers in C++ Solving the truncation problem Looking at the limits of floating-point numbers Declaring Variable Types Types of constants Special characters Are These Calculations Really Logical? Mixed Mode Expressions Chapter 3: Performing Mathematical Operations Performing Simple Binary Arithmetic Decomposing Expressions Determining the Order of Operations Performing Unary Operations Using Assignment Operators Chapter 4: Performing Logical Operations Why Mess with Logical Operations? Using the Simple Logical Operators Storing logical values Using logical int variables Be careful performing logical operations on floating-point variables Expressing Binary Numbers The decimal number system Other number systems The binary number system Performing Bitwise Logical Operations The single bit operators Using the bitwise operators A simple test Do something logical with logical calculations Chapter 5: Controlling Program Flow Controlling Program Flow with the Branch Commands Executing Loops in a Program Looping while a condition is true Using the autoincrement/autodecrement feature Using the for loop Avoiding the dreaded infinite loop Applying special loop controls Nesting Control Commands Switching to a Different Subject? Part II: Becoming a Functional C++ Programmer Chapter 6: Creating Functions Writing and Using a Function Defining the sumSequence( ) function Calling the function sumSequence( ) Divide and conquer Understanding the Details of Functions Understanding simple functions Understanding functions with arguments Overloading Function Names Defining Function Prototypes Variable Storage Types Including Include Files Chapter 7: Storing Sequences in Arrays Considering the Need for Arrays Using an array Initializing an array Accessing too far into an array Using arrays Defining and using arrays of arrays Using Arrays of Characters Creating an array of characters Creating a string of characters Manipulating Strings with Character String-ing Along Variables Chapter 8: Taking a First Look at C++ Pointers Variable Size What's in an Address? Address Operators Using Pointer Variables Comparing pointers and houses Using different types of pointers Passing Pointers to Functions Passing by value Passing pointer values Passing by reference Making Use of a Block of Memory Called the Heap Limiting scope Examining the scope problem Providing a solution using the heap Chapter 9: Taking a Second Look at C++ Pointers Defining Operations on Pointer Variables Re-examining arrays in light of pointer variables Applying operators to the address of an array Expanding pointer operations to a string Justifying pointer-based string manipulation Applying operators to pointer types other than char Contrasting a pointer with an array Declaring and Using Arrays of Pointers Utilizing arrays of character strings Accessing the arguments to main( ) Chapter 10: Debugging C++ Identifying Types of Errors Choosing the WRITE Technique for the Problem Catching bug #1 Catching bug #2 Calling for the Debugger Defining the debugger Finding commonalities among us Running a test program Single-stepping through a program Part III: Introduction to Classes Chapter 11: Examining Object-Oriented Programming Abstracting Microwave Ovens Preparing functional nachos Preparing object-oriented nachos Classifying Microwave Ovens Why Classify? Chapter 12: Adding Class to C++ Introducing the Class The Format of a Class Accessing the Members of a Class Chapter 13: Making Classes Work Activating Our Objects Simulating real-world objects Why bother with member functions? Adding a Member Function Creating a member function Naming class members Calling a Member Function Accessing a member function Accessing other members from a member function Scope Resolution (And I Don't Mean How Well Your Microscope Works) Defining a Member Function in the Class Keeping a Member Function After Class Overloading Member Functions Chapter 14: Point and Stare at Objects Defining Arrays of and Pointers to Simple Things Declaring Arrays of Objects Declaring Pointers to Objects Dereferencing an object pointer Pointing toward arrow pointers Passing Objects to Functions Calling a function with an object value Calling a function with an object pointer Calling a function by using the reference operator Why Bother with Either Pointers or References? Returning to the Heap Comparing Pointers to References Why Not Use References Rather Than Pointers? Linking Up with Linked Lists Performing other operations on a linked list Hooking up with a LinkedListData program A Ray of Hope: A List of Containers Linked to the C++ Library Chapter 15: Protecting Members: Do Not Disturb Protecting Members Why you need protected members Discovering how protected members work Making an Argument for Using Protected Members Protecting the internal state of the class Using a class with a limited interface Giving Non-Member Functions Access to Protected Members Chapter 16: "Why Do You Build Me Up,Just to Tear Me Down, Baby?" Creating Objects Using Constructors Why you need constructors Making constructors work Dissecting a Destructor Why you need the destructor Working with destructors Chapter 17: Making Constructive Arguments Outfitting Constructors with Arguments Justifying constructors Using a constructor Placing Too Many Demands on the Carpenter:Overloading the Constructor Defaulting Default Constructors Constructing Class Members Constructing a complex data member Constructing a constant data member Constructing the Order of Construction Local objects construct in order Static objects construct only once All global objects construct before main( ) Global objects construct in no particular order Members construct in the order in which they are declared Destructors destruct in the reverse order of the constructors Chapter 18: Copying the Copy Copy Copy Constructor Copying an Object Why you need the copy constructor Using the copy constructor The Automatic Copy Constructor Creating Shallow Copies versus Deep Copies It's a Long Way to Temporaries Avoiding temporaries, permanently Referring to the copy constructor's referential argument Chapter 19: Static Members: Can Fabric Softener Help? Defining a Static Member Why you need static members Using static members Referencing static data members Uses for static data members Declaring Static Member Functions What Is This About, Anyway? Part IV: Inheritance Chapter 20: Inheriting a Class Do I Need My Inheritance? How Does a Class Inherit? Using a subclass Constructing a subclass Destructing a subclass Having a HAS_A Relationship Chapter 21: Examining Virtual Member Functions: Are They for Real? Why You Need Polymorphism How Polymorphism Works When Is a Virtual Function Not? Considering Virtual Considerations Chapter 22: Factoring Classes Factoring Implementing Abstract Classes Describing the abstract class concept Making an honest class out of an abstract class Passing abstract classes Declaring pure virtual functions - is it really necessary? Factoring C++ Source Code Dividing the program - Student Defining a namespace Implementing Student Dividing the program - GraduateStudent Implementing an application Project file Creating a project file under Dev-C++ Part V: Optional Features Chapter 23: A New Assignment Operator, Should You Decide to Accept It Comparing Operators with Functions Inserting a New Operator Creating Shallow Copies Is a Deep Problem Overloading the Assignment Operator Protecting the Escape Hatch Chapter 24: Using Stream I/O How Stream I/O Works The fstream Subclasses Reading Directly from a Stream What's Up with endl? Using the strstream Subclasses Manipulating Manipulators Chapter 25: Handling Errors - Exceptions Justifying a New Error Mechanism? Examining the Exception Mechanism What Kinds of Things Can I Throw? Chapter 26: Inheriting Multiple Inheritance Describing the Multiple Inheritance Mechanism Straightening Out Inheritance Ambiguities Adding Virtual Inheritance Constructing the Objects of Multiple Inheritance Voicing a Contrary Opinion Chapter 27: Tempting C++ Templates Generalizing a Function into a Template Template Classes Do I Really Need Template Classes? Tips for Using Templates Chapter 28: Standardizing on the Standard Template Library The string Container The list Containers Iterators Using Maps Part VI: The Part of Tens Chapter 29: Ten Ways to Avoid Adding Bugs to Your Program Enabling All Warnings and Error Messages Insisting on Clean Compiles Adopting a Clear and Consistent Coding Style Limiting the Visibility Commenting Your Code While You Write It Single-Stepping Every Path at Least Once Avoid Overloading Operators Heap Handling Using Exceptions to Handle Errors Avoiding Multiple Inheritance Chapter 30: The Ten Most Important Optional Features of Dev-C++ Customize Editor Settings to Your Taste Highlight Matching Braces/Parentheses Enable Exception Handling Include Debugging Information (Sometimes) Create a Project File Customize the Help Menu Reset Breakpoints after Editing the File Avoid Illegal Filenames Include #include Files in Your Project Executing the Profiler Appendix: About the CD System Requirements Using the CD with Microsoft Windows Using the CD with Linux What You'll Find Development tools Program source code If You've Got Problems (Of the CD Kind) Index Team DDU The best-selling C++ For Dummies book makes C++ easier! C++ For Dummies, 7th Edition is the best-selling C++ guide on the market, fully revised for the 2014 update. With over 60% new content, this updated guide reflects the new standards, and includes a new Big Data focus that highlights the use of C++ among popular Big Data software solutions. The book provides step-by-step instruction from the ground up, helping beginners become programmers and allowing intermediate programmers to sharpen their skills. The companion website provides all code mentioned in the text, an updated GNU_C++, the new C++ compiler, and other applications. By the end of the first chapter, you will have programmed your first C++ application! As one of the most commonly used programming languages, C++ is a must-have skill for programmers who wish to remain versatile and marketable. C++ For Dummies, 7th Edition provides clear, concise, expert instruction, which is organized for easy navigation and designed for hands-on learning. Whether you're new to programming, familiar with other languages, or just getting up to speed on the new libraries, features, and generics, this guide provides the information you need. Provides you with an introduction to C++ programming Helps you become a functional programmer Features information on classes, inheritance, and optional features Teaches you 10 ways to avoid adding bugs The book incorporates the newest C++ features into the fundamental instruction, allowing beginners to learn the update as they learn the language. Staying current on the latest developments is a crucial part of being a programmer, and C++ For Dummies, 7th Edition gets you started off on the right foot. In the early 1970s, a consortium of really clever people worked on a computer system called Multix.