book

C++ All-in-One For Dummies, 3rd Edition

Name: C++ All-in-One For Dummies, 3rd Edition
ISBN: 9781118823798

by Jeff Cogswell, John Paul Mueller

August 2014

Intermediate to advanced

864 pages

19h 16m

English

For Dummies

Read now

Unlock full access

Introduction
No Experience NecessaryGreat for Advanced Folks, Too!For All ComputersConventionsOrganizationIcons GaloreWhat’s Next?Beyond the Book
Book I: Getting Started with C++
Chapter 1: Configuring Your System
Obtaining a Copy of C++ 14Obtaining Code::BlocksInstalling Code::BlocksWorking with WindowsWorking with Mac OS/XUsing the standard Linux installationUsing the graphical Linux installationTouring the Essential Code::Blocks FeaturesStarting Code::Blocks for the first timeOpening the sample projectsViewing the essential windowsUsing Other IDEs
Chapter 2: Creating Your First C++ Application
Code::Blocks Creating a ProjectUnderstanding projectsDefining your first projectBuilding and executing your first applicationTyping the CodeStarting with MainShowing InformationDoing some mathTabbing your outputLet Your Application Run Away
Chapter 3: Storing Data in C++
Putting Your Data Places: VariablesCreating an integer variableDeclaring multiple variablesChanging valuesSetting one variable equal to anotherInitializing a variableCreating a great name for yourselfManipulating Integer VariablesAdding integer variablesSubtracting integer variablesMultiplying integer variablesDividing integer variablesCharactersNull characterNonprintable and other cool charactersStringsGetting a part of a stringChanging part of a stringAdding onto a stringAdding two stringsDeciding between Conditional OperatorsTelling the Truth with Boolean VariablesReading from the Console
Chapter 4: Directing the Application Flow
Doing This or Doing ThatEvaluating Conditions in C++Finding the right C++ operatorsCombining multiple evaluationsIncluding Evaluations in C++ Conditional StatementsDeciding what if and also what elseGoing further with the else and ifRepeating Actions with Statements That LoopLooping situationsLooping forLooping whileDoing whileBreaking and continuingNesting loops
Chapter 5: Dividing Your Work with Functions
Dividing Your WorkCalling a FunctionPassing a variablePassing multiple variablesWriting Your Own FunctionsMultiple parameters or no parametersReturning nothingKeeping your variables localForward references and function prototypesWriting two versions of the same functionCalling All String FunctionsUnderstanding main()
Chapter 6: Splitting Up Source Code Files
Creating Multiple Source FilesSplitting a project into multiple source files in Code::BlocksCreating a project in Code::Blocks with multiple existing filesMultiple source files in other compilersCreating multiple filesSharing with Header FilesAdding the header only onceUsing brackets or quotesSharing Variables among Source FilesUsing the Mysterious Header Wrappers
Chapter 7: Referring to Your Data Through Pointers
Heaping and Stacking the VariablesGetting a variable’s addressChanging a variable by using a pointerPointing at a stringPointing to something elseTips on pointer variablesDynamically Allocating with newUsing newUsing an initializerMaking new stringsFreeing PointersPassing Pointer Variables to FunctionsChanging variable values with pointersModifying string parametersReturning Pointer Variables from FunctionsReturning a Pointer as a NonpointerPassing by ReferencePassing By const ReferenceRemembering the Rules
Chapter 8: Working with Classes
Understanding Objects and ClassesClassifying classes and objectsDescribing member functions and dataImplementing a classSeparating member function codeThe parts of a classWorking with a ClassAccessing membersUsing classes and pointersPassing objects to functionsUsing const parameters in functionsUsing the this pointerOverloading member functionsStarting and Ending with Constructors and DestructorsStarting with constructorsEnding with destructorsSampling constructors and destructorsAdding parameters to constructorsBuilding Hierarchies of ClassesCreating a hierarchy in C++Understanding types of inheritanceCreating and Using Object Aliases

Chapter 9: Using Advanced C++ Features
Filling Your Code with CommentsConverting TypesReading from the ConsoleUnderstanding Preprocessor DirectivesUsing ConstantsUsing Switch StatementsSupercharging enums with ClassesWorking with Random NumbersStoring Data in ArraysDeclaring and accessing an arrayArrays of pointersPassing arrays to functionsAdding and subtracting pointers
Book II: Understanding Objects and Classes
Chapter 1: Planning and Building Objects
Recognizing ObjectsObserving the Mailboxes classObserving the Mailbox classFinding other objectsEncapsulating ObjectsBuilding HierarchiesEstablishing a hierarchyProtecting members when inheritingOverriding member functionsSpecializing with polymorphismGetting abstract about thingsDiscovering ClassesEngineering your softwareFinding those pesky classes
Chapter 2: Describing Your Program with UML
Moving Up to UMLModeling with UMLDiagramming and designing with UMLBuilding with UML and the Rational Unified ProcessSpeaking iterativelyPhasing in and outThe inception phaseThe elaboration phaseThe construction phaseThe transition phaseMoving Forward with UML
Chapter 3: Structuring Your Classes with UML
Drawing ClassesMapping classes with UMLInheriting in UMLAggregating and composing classesBuilding ComponentsDeploying the Software
Chapter 4: Demonstrating Behavior with UML
Drawing ObjectsCasing Out the Use CasesExpanding use casesMatching use cases and requirementsSequence DiagramsNotating sequence diagramsLooping and comparing in sequence diagramsCollaboration DiagramsActivity DiagramsState Diagrams
Chapter 5: Modeling Your Applications with UML
Using UML GoodiesPackaging your symbolsNotating your diagramsTagging your symbolsFree to Be UMLC++ and UMLDrawing enumerationsIncluding static membersParameterizing classes with templates
Chapter 6: Building with Design Patterns
Introducing a Simple Pattern: the SingletonWatching an Instance with an ObserverObservers and the Standard C++ LibraryAutomatically adding an observerMediating with a Pattern
Book III: Fixing Problems
Chapter 1: Dealing with Bugs
It’s Not a Bug. It’s a Feature!Make Your Application Features Look Like FeaturesAnticipating (Almost) EverythingAvoiding Mistakes, Plain and Simple
Chapter 2: Debugging an Application
Programming with DebuggersRunning the debuggerRecognizing the parts of the Code::Blocks debuggerDebugging with Different ToolsStandard debuggersDebugging a Code::Blocks Application with Command Line Arguments
Chapter 3: Stopping and Inspecting Your Code
Setting and Disabling BreakpointsSetting a breakpoint in Code::BlocksEnabling and disabling breakpointsWatching, Inspecting, and Changing VariablesWatching the variablesWatching objectsChanging values
Chapter 4: Traveling About the Stack
Stacking Your DataMoving about the stackStoring local variablesDebugging with Advanced FeaturesViewing threadsTracing through assembly code
Book IV: Advanced Programming
Chapter 1: Working with Arrays, Pointers, and References
Building Up ArraysDeclaring arraysArrays and pointersUsing multidimensional arraysArrays and command-line parametersAllocating an array on the heapStoring arrays of pointers and arrays of arraysBuilding constant arraysPointing with PointersBecoming horribly complexPointers to functionsPointing a variable to a member functionPointing to static member functionsReferring to ReferencesReference variablesReturning a reference from a function
Chapter 2: Creating Data Structures
Working with DataThe great variable roundupExpressing variables from either sideCasting a spell on your dataCasting safely with C++Dynamically casting with dynamic_castStatically casting with static_castStructuring Your DataStructures as component data typesEquating structuresReturning compound data typesNaming Your SpaceUsing variables and part of a namespace
Chapter 3: Constructors, Destructors, and Exceptions
Constructing and Destructing ObjectsOverloading constructorsInitializing membersAdding a default constructorFunctional constructorsCalling one constructor from anotherCopying instances with copy constructorsWhen constructors go bad: Failable constructors?Destroying your instancesVirtually inheriting destructorsProgramming the Exceptions to the RuleThrowing direct instancesCatching any exceptionRethrowing an exception
Chapter 4: Advanced Class Usage
Inherently Inheriting CorrectlyMorphing your inheritanceAdjusting accessReturning something different, virtually speakingMultiple inheritanceVirtual inheritanceFriend classes and functionsUsing Classes and Types within ClassesNesting a classTypes within classes
Chapter 5: Creating Classes with Templates
Templatizing a ClassSeparating a template from the function codeIncluding static members in a templateParameterizing a TemplatePutting different types in the parameterIncluding multiple parametersTypedefing a TemplateDeriving TemplatesDeriving classes from a class templateDeriving a class template from a classDeriving a class template from a class templateTemplatizing a FunctionOverloading and function templatesTemplatizing a member function
Chapter 6: Programming with the Standard Library
Architecting the Standard LibraryContaining Your ClassesStoring in a vectorMapping your dataContaining instances, pointers, or referencesComparing instancesIterating through a containerA map of pairs in your handThe Great Container ShowdownAssociating and storing with a setUnionizing and intersecting setsListing with listStacking the dequeWaiting in line with stacks and queuesCopying ContainersCreating and Using Dynamic ArraysConfiguring the IDEDeclaring a dynamic arrayWorking with Unordered DataUsing std::unordered_set to create an unordered setManipulating unordered sets
Chapter 7: Working with Lambda Expressions
Creating More Readable and Concise C++ CodeDefining the Essential Lambda ExpressionDefining the parts of a lambda expressionRelying on compiler detection of return typeUsing a specific return typeUsing the auto keywordDeveloping Applications with Lambda ExpressionsCreating lambda expressions with multiple inputsWorking with the capture clauseSorting data using a lambda expressionSpecifying that the lambda expression throws exceptions
Book V: Reading and Writing Files
Chapter 1: Filing Information with the Streams Library
Seeing a Need for StreamsProgramming with the Streams LibraryGetting the right header fileOpening a fileHandling Errors When Opening a FileFlagging the ios Flags
Chapter 2: Writing with Output Streams
Inserting with the << OperatorFormatting Your OutputFormatting with flagsSpecifying a precisionSetting the width and creating fields
Chapter 3: Reading with Input Streams
Extracting with OperatorsEncountering the End of FileReading Various TypesReading Formatted Input
Chapter 4: Building Directories and Contents
Manipulating DirectoriesCreating a directoryDeleting a directoryGetting the Contents of a DirectoryCopying FilesMoving and Renaming Files and Directories
Chapter 5: Streaming Your Own Classes
Streaming a Class for Text FormattingManipulating a StreamWhat’s a manipulator?Writing your own manipulator
Book VI: Advanced C++
Chapter 1: Exploring the Standard Library Further
Considering the Standard Library CategoriesContainersIteratorsAlgorithmsFunctorsUtilitiesAdaptorsAllocatorsPolymorphic allocatorsParsing Strings Using a HashObtaining Information Using a Random Access IteratorLocating Values Using the Find AlgorithmUsing the Random Number GeneratorPerforming Comparisons Using min and maxWorking with Temporary Buffers
Chapter 2: Working with User-Defined Literals (UDLs)
Understanding the Need for UDLsPrefixes and suffixesDifferentiating between raw and cookedWorking with the UDLs Included in the Standard Librarystd::basic_stringstd::complexstd::chrono::durationCreating Your Own UDLsDeveloping a conversion UDLDeveloping a custom type UDLUsing a custom UDL for side effects
Chapter 3: Building Original Templates
Deciding When to Create a TemplateDefining the Elements of a Good TemplateCreating a Basic Math TemplateBuilding a Structure TemplateDeveloping a Class TemplateConsidering Template SpecializationCreating a Template LibraryDefining the library projectConfiguring the library projectCoding the libraryUsing Your Template Library
Chapter 4: Investigating Boost
Understanding BoostBoost featuresLicensingPaid supportObtaining and Installing Boost for Code::BlocksUnpacking BoostUsing the header-only librariesBuilding the librariesTesting the installationCreating the Boost ToolsUsing Boost.BuildGetting a successful buildUsing the examplesUsing RegressionUsing InspectUnderstanding BoostBookUsing QuickBookUsing bcpUsing WaveBuilding Your First Boost Application Using Date Time
Chapter 5: Boosting up a Step
Parsing Strings Using RegExAdding the RegEx libraryCreating the RegEx codeBreaking Strings into Tokens Using TokenizerPerforming Numeric ConversionCreating Improved Loops Using ForeachAccessing the Operating System Using Filesystem
Appendix: Automating Your Applications with Makefiles
Compiling and LinkingAutomating Your WorkImplying with Inference RulesUsing rules that depend on other rulesMaking specific itemsDepending on multiple filesCompiling and linking with makeCleaning up and making it allUsing macrosGetting the most out of Makefiles
About the Authors
Cheat Sheet
More Dummies Products

Content preview from C++ All-in-One For Dummies, 3rd Edition

Chapter 2

Creating Your First C++ Application

In This Chapter

Organizing your applications into projects

Typing code into the code editor

Writing an application that writes to the screen

Doing basic math

Running your application

It’s your lucky day. You have decided to learn the most popular programming language on the planet. From the biggest skyscrapers housing huge Fortune 500 companies all the way down to the garages with the self-starting kids grinding out the next generation of software, people are using C++. Yes, there are other languages, but more programmers use C++ than any other language. In this chapter, you start right out writing a C++ application.

As mentioned in Chapter 1, this book relies on your use of Code::Blocks as the IDE and on GCC as the C++ compiler. The procedures are written for the most current version of Code::Blocks (version 12.11) at the time of writing, ...

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: 9781118823798Purchase 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, 3rd Edition

by Jeff Cogswell, John Paul Mueller

Creating Your First C++ Application

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.