book

C++ All-In-One For Dummies®, 2nd Edition

Name: C++ All-In-One For Dummies®, 2nd Edition
ISBN: 9780470317358

by John Paul Mueller, Jeff Cogswell

August 2009

Beginner

864 pages

18h 40m

English

For Dummies

Read now

Unlock full access

Copyright
About the Authors
Authors' Acknowledgments
Publisher's Acknowledgments
Introduction
No Experience NecessaryGreat for Advanced Folks, Too!For All ComputersConventionsOrganizationIcons GaloreWhat's Next?
I. Introducing C++
1. Creating a First C++ Program
1.1. Creating a Project1.1.1. Understanding projects1.1.2. Defining your first project1.1.3. Building and executing your first application1.2. Typing the Code1.3. Starting with Main1.4. Showing Information1.4.1. Doing some math1.4.1.1. Ordering the operations1.4.1.2. Going overboard1.4.1.3. Pairing the parentheses1.4.2. Tabbing your output1.5. Let Your Program Run Away
2. Storing Data in C++
2.1. Putting Your Data Places: Variables2.1.1. Creating an integer variable2.1.2. Declaring multiple variables2.1.3. Changing values2.1.4. Setting one variable equal to another2.1.5. Initializing a variable2.1.6. Creating a great name for yourself2.2. Manipulating Integer Variables2.2.1. Adding integer variables2.2.2. Subtracting integer variables2.2.3. Multiplying integer variables2.2.4. Dividing integer variables2.3. Characters2.3.1. Null character2.3.2. Nonprintable and other cool characters2.4. Strings2.4.1. Getting a part of a string2.4.2. Changing part of a string2.4.3. Adding onto a string2.4.4. Adding two strings2.5. Deciding between Conditional Operators2.6. Telling the Truth with Boolean Variables2.7. Reading from the Console
3. Directing Your C++ Program Flow
3.1. Doing This or Doing That3.2. Evaluating Conditions in C++3.2.1. Finding the right C++ operators3.2.2. Combining multiple evaluations3.3. Including Evaluations in C++ Conditional Statements3.3.1. Deciding what if and also what else3.3.2. Going further with the else and if3.4. Repeating Actions with Statements That Loop3.4.1. Looping situations3.4.2. Looping for3.4.2.1. Meddling with the middle condition3.4.2.2. Going backwards3.4.2.3. Incrementing one step at a time3.4.2.4. Getting sneaky (and too complicated)3.4.3. Looping while3.4.4. Doing while3.4.5. Breaking and continuing3.4.5.1. Breaking3.4.5.2. Continuing3.4.6. Nesting loops
4. Dividing Your Work with Functions
4.1. Dividing Your Work4.2. Calling a Function4.2.1. Passing a variable4.2.2. Passing multiple variables4.3. Writing Your Own Functions4.3.1. Multiple parameters or no parameters4.3.2. Returning nothing4.3.3. Keeping your variables local4.3.4. Forward references and function prototypes4.3.5. Writing two versions of the same function4.4. Calling All String Functions4.5. Understanding main

5. Dividing Between Source-Code Files
5.1. Creating Multiple Source Files5.1.1. Multiple source files in CodeBlocks5.1.2. Multiple source files in other compilers5.1.3. Creating multiple files5.2. Sharing with Header Files5.2.1. Adding the header only once5.2.2. Using brackets or quotes5.3. Sharing Variables Among Source Files5.4. Using the Mysterious Header Wrappers
6. Referring to Your Data Through Pointers
6.1. Heaping and Stacking the Variables6.1.1. Getting a variable's address6.1.2. Changing a variable by using a pointer6.1.3. Pointing at a string6.1.4. Pointing to something else6.1.5. Tips on pointer variables6.2. Dynamically Allocating with new6.2.1. Using new6.2.2. Using an initializer6.2.3. Making new strings6.3. Freeing Pointers6.4. Passing Pointer Variables to Functions6.4.1. Changing variable values with pointers6.4.2. Modifying string parameters6.5. Returning Pointer Variables from Functions6.6. Returning a Pointer as a Nonpointer6.7. Passing by Reference6.8. Remembering the Rules
7. Working with Classes
7.1. Understanding Objects and Classes7.1.1. Classifying classes and objects7.1.2. Describing member functions and data7.1.3. Implementing a class7.1.4. Separating member function code7.1.5. The parts of a class7.2. Working with a Class7.2.1. Accessing members7.2.2. Using classes and pointers7.2.3. Passing objects to functions7.2.4. Using const parameters in functions7.2.5. Using the this pointer7.2.6. Overloading member functions7.3. Starting and Ending with Constructors and Destructors7.3.1. Starting with constructors7.3.2. Ending with destructors7.3.3. Sampling constructors and destructors7.3.4. Adding parameters to constructors7.4. Building Hierarchies of Classes7.4.1. Creating a hierarchy in C++7.4.2. Understanding types of inheritance
8. Using Advanced C++ Features
8.1. Filling Your Code with Comments8.2. Converting Types8.3. Reading from the Console8.4. Understanding Preprocessor Directives8.5. Using Constants8.6. Using Switch Statements8.7. Supercharging enums with Classes8.8. Working with Random Numbers8.9. Storing Data in Arrays8.9.1. Declaring and accessing an array8.9.2. Arrays of pointers8.9.3. Passing arrays to functions8.9.4. Adding and subtracting pointers
II. Understanding Objects and Classes
1. Planning and Building Objects
1.1. Recognizing Objects1.1.1. Observing the mailboxes class1.1.2. Observing the mailbox class1.1.3. Finding other objects1.2. Encapsulating Objects1.3. Building Hierarchies1.3.1. Establishing a hierarchy1.3.2. Protecting members when inheriting1.3.3. Overriding member functions1.3.4. Specializing with polymorphism1.3.5. Getting abstract about things1.4. Discovering Classes1.4.1. Engineering your software1.4.2. Finding those pesky classes1.4.2.1. Searching for nouns and verbs1.4.2.2. Using CRC cards1.4.2.3. Look for hidden or missing classes1.4.2.4. Completing the analysis with the design workflow
2. Describing Your Program with UML
2.1. Moving Up to UML2.1.1. Modeling with UML2.1.2. Diagramming and designing with UML2.2. Building with UML and the Unified Process2.2.1. Speaking iteratively2.2.2. Phasing in and out2.2.3. The inception phase2.2.4. The elaboration phase2.2.5. The construction phase2.2.6. The transition phase2.3. Moving Forward with UML
3. Structuring Your Classes with UML
3.1. Drawing Classes3.1.1. Mapping classes with UML3.1.2. Inheriting in UML3.1.3. Aggregating and composing classes3.2. Building Components3.3. Deploying the Software
4. Demonstrating Behavior with UML
4.1. Drawing Objects4.2. Casing Out the Use Cases4.2.1. Expanding use cases4.2.2. Matching use cases and requirements4.3. Sequence Diagrams4.3.1. Notating sequence diagrams4.3.2. Looping and comparing in sequence diagrams4.4. Collaboration Diagrams4.5. Activity Diagrams4.6. State Diagrams
5. Modeling Your Programs with UML
5.1. Using UML Goodies5.1.1. Packaging your symbols5.1.2. Notating your diagrams5.1.3. Tagging your symbols5.2. Free to Be UML5.3. C++ and UML5.3.1. Drawing enumerations5.3.2. Including static members5.3.3. Parameterizing classes with templates
6. Building with Design Patterns
6.1. Introducing a Simple Pattern: the Singleton6.2. Watching an Instance with an Observer6.2.1. Observers and the Standard C++ Library6.2.2. Automatically adding an observer6.3. Mediating with a Pattern
III. Fixing Problems
1. Dealing with Bugs
1.1. It's Not a Bug. It's a Feature!1.2. Make Your Programming Features Look Like Features1.3. Anticipating (Almost) Everything1.4. Avoiding Mistakes, Plain and Simple
2. Debugging a Program
2.1. Programming with Debuggers2.1.1. Running the debugger2.1.2. Recognizing the parts of the CodeBlocks debugger2.2. Debugging with Different Tools2.2.1. Standard debuggers
3. Stopping and Inspecting Your Code
3.1. Setting and Disabling Breakpoints3.1.1. Setting a breakpoint in CodeBlocks3.1.2. Enabling and disabling breakpoints3.2. Watching, Inspecting, and Changing Variables3.2.1. Watching the local variables3.2.2. Watching other variables
4. Traveling About the Stack
4.1. Stacking Your Data4.1.1. Moving about the stack4.1.2. Storing local variables4.2. Debugging with Advanced Features4.2.1. Viewing threads4.2.2. Tracing through assembly code
IV. Advanced Programming
1. Working with Arrays, Pointers, and References
1.1. Building Up Arrays1.1.1. Declaring arrays1.1.2. Arrays and pointers1.1.3. Using multidimensional arrays1.1.3.1. Initializing multidimensional arrays1.1.3.2. Passing multidimensional arrays1.1.4. Arrays and command-line parameters1.1.5. Allocating an array on the heap1.1.6. Storing arrays of pointers and arrays of arrays1.1.7. Building constant arrays1.2. Pointing with Pointers1.2.1. Becoming horribly complex1.2.2. Pointers to functions1.2.3. Pointing a variable to a member function1.2.4. Pointing to static member functions1.3. Referring to References1.3.1. Reference variables1.3.2. Returning a reference from a function
2. Creating Data Structures
2.1. Working with Data2.1.1. The great variable roundup2.1.2. Expressing variables from either side2.1.3. Casting a spell on your data2.1.4. Casting safely with C++2.1.5. Dynamically casting with dynamic_cast2.1.6. Statically casting with static_cast2.2. Structuring Your Data2.2.1. Structures as component data types2.2.2. Equating structures2.2.3. Returning compound data types2.3. Naming Your Space2.3.1. Using variables and part of a namespace
3. Constructors, Destructors, and Exceptions
3.1. Constructing and Destructing Objects3.1.1. Overloading constructors3.1.2. Initializing members3.1.3. Adding a default constructor3.1.4. Functional constructors3.1.5. Calling one constructor from another3.1.6. Copying instances with copy constructors3.1.7. When constructors go bad: failable constructors?3.1.8. Destroying your instances3.1.9. Virtually inheriting destructors3.2. Programming the Exceptions to the Rule3.2.1. Throwing direct instances3.2.2. Catching any exception3.2.3. Rethrowing an exception
4. Advanced Class Usage
4.1. Inherently Inheriting Correctly4.1.1. Morphing your inheritance4.1.2. Adjusting access4.1.3. Returning something different, virtually speaking4.1.4. Multiple inheritance4.1.5. Virtual inheritance4.1.6. Friend classes and functions4.2. Using Classes and Types within Classes4.2.1. Nesting a class4.2.2. Types within classes
5. Creating Classes with Templates
5.1. Templatizing a Class5.1.1. Separating a template from the function code5.1.2. Including static members in a template5.2. Parameterizing a Template5.2.1. Putting different types in the parameter5.2.2. Including multiple parameters5.3. Typedefing a Template5.4. Deriving Templates5.4.1. Deriving classes from a class template5.4.2. Deriving a class template from a class5.4.3. Deriving a class template from a class template5.5. Templatizing a Function5.5.1. Overloading and function templates5.5.2. Templatizing a member function
6. Programming with the Standard Library
6.1. Architecting the Standard Library6.2. Containing Your Classes6.2.1. Storing in a vector6.2.2. Mapping your data6.2.3. Containing instances, pointers, or references6.2.4. Comparing instances6.2.5. Iterating through a container6.2.6. A map of pairs in your hand6.3. The Great Container Showdown6.3.1. Associating and storing with a set6.3.2. Unionizing and intersecting sets6.3.3. Listing with list6.3.4. Stacking the deque6.3.5. Waiting in line with stacks and queues6.4. Copying Containers
V. Reading and Writing Files
1. Filing Information with the Streams Library
1.1. Seeing a Need for Streams1.2. Programming with the Streams Library1.2.1. Getting the right header file1.2.2. Opening a file1.3. Handling Errors When Opening a File1.4. Flagging the ios Flags
2. Writing with Output Streams
2.1. Inserting with the << Operator2.2. Formatting Your Output2.2.1. Formatting with flags2.2.2. Specifying a precision2.2.3. Setting the width and creating fields
3. Reading with Input Streams
3.1. Extracting with Operators3.2. Encountering the End of File3.3. Reading Various Types3.4. Reading Formatted Input
4. Building Directories and Contents
4.1. Manipulating Directories4.1.1. Creating a directory4.1.2. Deleting a directory4.2. Getting the Contents of a Directory4.3. Copying Files4.4. Moving and Renaming Files and Directories
5. Streaming Your Own Classes
5.1. Streaming a Class for Text Formatting5.2. Manipulating a Stream5.2.1. What's a manipulator?5.2.2. Writing your own manipulator
VI. Advanced C++
1. Exploring the Standard Library Further
1.1. Considering the Standard Library Categories1.1.1. Containers1.1.2. Iterators1.1.3. Algorithms1.1.4. Functors1.1.5. Utilities1.1.6. Adaptors1.1.7. Allocators1.2. Parsing Strings Using a Hash1.3. Obtaining Information Using a Random Access Iterator1.4. Locating Values Using the Find Algorithm1.5. Using the Random Number Generator1.6. Performing Comparisons Using min and max1.7. Working with Temporary Buffers
2. Building Original Templates
2.1. Deciding When to Create a Template2.2. Defining the Elements of a Good Template2.3. Creating a Basic Math Template2.4. Building a Structure Template2.5. Developing a Class Template2.6. Considering Template Specialization2.7. Creating a Template Library2.7.1. Defining the library project2.7.2. Configuring the library project2.7.3. Coding the library2.8. Using Your Template Library
3. Investigating Boost
3.1. Understanding Boost3.1.1. Boost features3.1.2. Licensing3.1.3. Paid support3.2. Obtaining and Installing Boost for CodeBlocks3.2.1. Unpacking Boost3.2.2. Building the libraries3.2.3. Building the Boost tools3.3. Using Boost Jam3.4. Using Boost Build3.5. Using Regression3.6. Using Inspect3.7. Understanding BoostBook3.8. Using QuickBook3.9. Using bcp3.10. Using Wave3.11. Building Your First Boost Application Using Date Time
4. Boosting up a Step
4.1. Parsing Strings Using RegEx4.1.1. Adding the RegEx library4.1.2. Creating the RegEx code4.2. Breaking Strings into Tokens Using Tokenizer4.3. Performing Numeric Conversion4.4. Creating Improved Loops Using Foreach4.5. Accessing the Operating System Using Filesystem
VII. Building Applications with Mircosoft MFC
1. Working with the Visual C++ 2008 IDE and Projects
1.1. Understanding the Project Types1.2. Creating a New Win32 Console Application1.2.1. Defining the project1.2.2. Adding code1.2.3. Running the application1.3. Writing Code Faster1.3.1. Obtaining coding help1.3.2. Working with IntelliSense1.4. Viewing Your Project in Solution Explorer1.5. Using the Standard Toolbars1.6. Changing Application Properties1.7. Modifying the IDE Appearance1.7.1. Changing toolbars and menus1.7.2. Modifying windows
2. Creating an MFC Dialog Box Project
2.1. Understanding the MFC Dialog Box Project2.2. Creating the MFC Dialog Box Project2.3. Adding Components and Controls2.3.1. Adding the component or control2.3.2. Creating variables to use in your code2.3.3. Defining methods to react to control events2.4. Defining the Dialog Box Code2.5. Understanding the Essential Windows2.5.1. Working with Class View2.5.2. Modifying the Toolbox
3. Creating an MFC SDI Project
3.1. Understanding the MFC SDI Project3.2. Creating the MFC SDI Project3.3. Understanding the Document/View Architecture3.4. Adding Code to Your SDI Project3.4.1. An overview of the essential application files3.4.2. Locating Microsoft specified suggested changes3.4.3. Making resource changes3.4.4. Considering the help file3.4.5. Registering and unregistering the application3.5. Seeing the Text Editor Project in Action
4. Using the Visual C++ 2008 Debugger
4.1. A Quick Look at the Error Application4.2. Starting Your Application in Debugging Mode4.2.1. Creating the proper build4.2.2. Setting breakpoints4.2.3. Viewing your breakpoints4.2.4. Starting the debugger4.3. Working with the Debugging Windows4.3.1. Viewing the focus variables using the Autos window4.3.2. Viewing all of the variables in a method using the Locals window4.3.3. Screening specific variables using the Watch 1 window4.3.4. Working with the Call Stack window
5. Analyzing Your Visual C++ 2008 Code
5.1. Using Performance Wizard5.2. Profiling the Code
A. Automating Your Programs with Makefiles
A.1. Compiling and LinkingA.2. Automating Your WorkA.3. Implying with Inference RulesA.3.1. Using rules that depend on other rulesA.3.2. Making specific itemsA.3.3. Depending on multiple filesA.3.4. Compiling and linking with makeA.3.5. Cleaning up and making it allA.3.6. Using macrosA.3.7. Getting the most out of Makefiles
B. About the CD
B.1. System RequirementsB.2. Using the CDB.3. What You'll Find on the CDB.3.1. CodeBlocks CompilerB.3.2. Author-created materialB.4. TroubleshootingB.5. Customer Care

Content preview from C++ All-In-One For Dummies®, 2nd Edition

Chapter 1. Planning and Building Objects

In This Chapter

Recognizing objects so you can create classes
Encapsulating classes into self-contained capsules
Building hierarchies of classes through inheritance
Discovering classes

Step outside for a moment and look down. What is the thing you are standing on? (Hint: It's giant, it's made of rock and sand and stone and molten lava, and it's covered with oceans and land.) The answer? A thing! (Even a planet is a thing.) And now go back inside. What's the thing that you opened, the thing with a doorknob? It's a thing, too! It's a slightly different kind of thing, but a thing nevertheless. And what are you inside? Okay, you get the idea. Everything you can imagine is a thing. Or, to use another term, an object. Remember that word: object.

Over the years, researchers in the world of computer programming (now, doesn't that sound like an exciting job?) have figured out that the best way to program computers is to divide whatever it is you're trying to model into a bunch of objects. These objects have capabilities and characteristics. (Eventually they have relationships, but that comes later.)

In this chapter, we show you how to make use of objects to create a software application. In the process, you get to twist some of the nuts and bolts of C++ that relate to objects and get tips on how to get the most out of them.

Recognizing Objects

Let's get to the meat of it: Think of an object as any thing that a computer can describe. (Object = thing. How's ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9780470317358Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C++ All-In-One For Dummies®, 2nd Edition

by John Paul Mueller, Jeff Cogswell

Chapter 1. Planning and Building Objects

Recognizing Objects

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.