book

Sams Teach Yourself C++ in One Hour a Day, Sixth Edition

Name: Sams Teach Yourself C++ in One Hour a Day, Sixth Edition
ISBN: 9780768678598

by Jesse Liberty, Siddhartha Rao, Bradley Jones

July 2008

Beginner

888 pages

16h 30m

English

Sams

Read now

Unlock full access

Copyright
Lead Author, Sixth Edition
Contributing Authors
Acknowledgments
We Want to Hear from You!
Reader Services
Introduction
Who Should Read This BookOrganization of This BookConventions Used in This BookSample Code for This Book
I. The Basics
1. Getting Started
A Brief History of C++Interpreters and CompilersChanging Requirements, Changing PlatformsProcedural, Structured, and Object-Oriented ProgrammingObject-Oriented ProgrammingC++ and Object-Oriented ProgrammingEncapsulationInheritance and ReusePolymorphismHow C++ EvolvedShould I Learn C First?Microsoft’s Managed Extensions to C++The ANSI StandardPreparing to ProgramYour Development EnvironmentThe Process of Creating the ProgramCreating an Object File with the CompilerCreating an Executable File with the LinkerThe Development CycleHELLO.cpp—Your First C++ ProgramGetting Started with Your CompilerBuilding the Hello World ProjectCompile ErrorsSummaryQ&AWorkshopQuizExercises
2. The Anatomy of a C++ Program
A Simple ProgramA Brief Look at coutUsing the Standard NamespaceCommenting Your ProgramsTypes of CommentsUsing CommentsA Final Word of Caution About CommentsFunctionsUsing FunctionsMethods Versus FunctionsSummaryQ&AWorkshopQuizExercises

3. Using Variables, Declaring Constants
What Is a Variable?Storing Data in MemorySetting Aside MemorySize of Integerssigned and unsignedFundamental Variable TypesDefining a VariableCase SensitivityNaming ConventionsKeywordsDetermining Memory Consumed by a Variable TypeCreating More Than One Variable at a TimeAssigning Values to Your VariablesCreating Aliases with typedefWhen to Use short and When to Use longWrapping Around an unsigned IntegerWrapping Around a signed IntegerWorking with CharactersCharacters and NumbersSpecial Printing CharactersConstantsLiteral ConstantsSymbolic ConstantsDefining Constants with #defineDefining Constants with constEnumerated ConstantsSummaryQ&AWorkshopQuizExercises
4. Managing Arrays and Strings
What Is an Array?Accessing Array ElementsWriting Past the End of an ArrayFence Post ErrorsInitializing ArraysDeclaring ArraysMultidimensional ArraysDeclaring Multidimensional ArraysInitializing Multidimensional Arrayschar Arrays and StringsUsing the strcpy() and strncpy() MethodsString ClassesSummaryQ&AWorkshopQuizExercises
5. Working with Expressions, Statements, and Operators
Starting with StatementsUsing WhitespaceBlocks and Compound StatementsExpressionsWorking with OperatorsAssignment OperatorsMathematical OperatorsSubtraction TroublesInteger Division and ModulusCombining the Assignment and Mathematical OperatorsIncrementing and DecrementingPrefixing Versus PostfixingUnderstanding Operator PrecedenceNesting ParenthesesThe Nature of TruthEvaluating with the Relational OperatorsThe if StatementIndentation StylesThe else StatementAdvanced if StatementsUsing Braces in Nested if StatementsUsing the Logical OperatorsThe Logical AND OperatorThe Logical OR OperatorThe Logical NOT OperatorShort Circuit EvaluationRelational PrecedenceMore About Truth and FalsehoodThe Conditional (Ternary) OperatorSummaryQ&AWorkshopQuizExercises
6. Organizing Code with Functions
What Is a Function?Return Values, Parameters, and ArgumentsDeclaring and Defining FunctionsFunction PrototypesDefining the FunctionExecution of FunctionsDetermining Variable ScopeLocal VariablesLocal Variables Within BlocksParameters Are Local VariablesGlobal VariablesGlobal Variables: A Word of CautionConsiderations for Creating Function StatementsMore About Function ArgumentsMore About Return ValuesDefault ParametersOverloading FunctionsSpecial Topics About FunctionsInline FunctionsRecursionHow Functions Work—A Peek Under the HoodLevels of AbstractionPartitioning RAMThe Stack and FunctionsSummaryQ&AWorkshopQuizExercises
7. Controlling Program Flow
Programming LoopsThe Roots of Looping: gotoWhy goto Is ShunnedUsing while LoopsExploring More Complicated while StatementsIntroducing continue and breakExamining while(true) LoopsImplementing do...while LoopsUsing do...whileLooping with the for StatementAdvanced for LoopsMultiple Initialization and IncrementsNull Statements in for LoopsEmpty for LoopsNesting LoopsScoping in for LoopsSumming Up LoopsControlling Flow with switch StatementsUsing a switch Statement with a MenuSummaryQ&AWorkshopQuizExercises
8. Pointers Explained
What Is a Pointer?A Bit About MemoryGetting a Variable’s Memory AddressStoring a Variable’s Address in a PointerPointer NamesGetting the Value from a VariableDereferencing with the Indirection OperatorPointers, Addresses, and VariablesManipulating Data by Using PointersExamining the AddressPointers and Array NamesA Pointer to an Array Versus an Array of PointersWhy Would You Use Pointers?The Stack and the Free Store (Heap)Allocating Space with the new KeywordPutting Memory Back: The delete KeywordAnother Look at Memory LeaksCreating Objects on the Free StoreDeleting Objects from the Free StoreStray, Wild, or Dangling PointersUsing const PointersSummaryQ&AWorkshopQuizExercises
9. Exploiting References
What Is a Reference?Using the Address-Of Operator (&) on ReferencesAttempting to Reassign References (Not!)Null Pointers and Null ReferencesPassing Function Arguments by ReferenceMaking swap() Work with PointersImplementing swap() with ReferencesReturning Multiple ValuesReturning Values by ReferencePassing by Reference for EfficiencyPassing a const PointerReferences as an AlternativeKnowing When to Use References Versus PointersMixing References and PointersReturning Out-of-Scope Object ReferencesThe Problem with Returning a Reference to an Object on the Heap/Free StoreSummaryQ&AWorkshopQuizExercises
II. Fundamentals of Object-Oriented Programming and C++
10. Classes and Objects
Is C++ Object-Oriented?Creating New TypesIntroducing Classes and MembersDeclaring a ClassA Word on Naming ConventionsDefining an ObjectClasses Versus ObjectsAccessing Class MembersAssigning to Objects, Not to ClassesIf You Don’t Declare It, Your Class Won’t Have ItPrivate Versus Public AccessMaking Member Data PrivateImplementing Class MethodsAdding Constructors and DestructorsGetting a Default Constructor and DestructorUsing the Default ConstructorIncluding const Member FunctionsWhere to Put Class Declarations and Method DefinitionsInline ImplementationClasses with Other Classes as Member DataExploring StructuresSummaryQ&AWorkshopQuizExercises
11. Implementing Inheritance
What Is Inheritance?Inheritance and DerivationThe Animal KingdomThe Syntax of DerivationPrivate Versus ProtectedInheritance with Constructors and DestructorsPassing Arguments to Base ConstructorsOverriding Base Class FunctionsHiding the Base Class MethodCalling the Base MethodVirtual MethodsHow Virtual Functions WorkTrying to Access Methods from a Base ClassSlicingCreating Virtual DestructorsVirtual Copy ConstructorsThe Cost of Virtual MethodsPrivate InheritanceUsing Private InheritancePrivate Inheritance Versus Aggregation (Composition)SummaryQ&AWorkshopQuizExercises
12. Polymorphism
Problems with Single InheritancePercolating UpwardCasting DownAdding to Two ListsMultiple InheritanceThe Parts of a Multiply Inherited ObjectConstructors in Multiply Inherited ObjectsAmbiguity ResolutionInheriting from Shared Base ClassVirtual InheritanceProblems with Multiple InheritanceMixins and Capabilities ClassesAbstract Data TypesPure Virtual FunctionsImplementing Pure Virtual FunctionsComplex Hierarchies of AbstractionWhich Classes Are Abstract?SummaryQ&AWorkshopQuizExercises
13. Operator Types and Operator Overloading
What Are Operators in C++?Unary OperatorsTypes of Unary OperatorsProgramming a Unary Increment/Decrement OperatorProgramming Dereference Operator * and Member Selection Operator ->Programming Conversion OperatorsBinary OperatorsTypes of Binary OperatorsProgramming Binary Addition (a+b) and Subtraction (a−b) OperatorsProgramming Addition-Assignment and Subtraction-Assignment OperatorsOverloading Comparison OperatorsOverloading <, >, <=, and >= OperatorsSubscript OperatorsFunction operator()Operators That Cannot Be RedefinedSummaryQ&AWorkshopQuizExercises
14. Casting Operators
What Is Casting?The Need for CastingWhy C-Style Casts Are Not Popular with Some C++ ProgrammersThe C++ Casting OperatorsUsing static_castUsing dynamic_cast and Runtime Type IdentificationUsing reinterpret_castUsing const_castProblems with the C++ Casting OperatorsSummaryQ&AWorkshopQuiz
15. An Introduction to Macros and Templates
The Preprocessor and the CompilerThe #define Preprocessor DirectiveMacro FunctionsWhy All the Parentheses?How Macros and Poor Type Safety Go Hand-in-HandMacros Versus Functions and TemplatesInline FunctionsAn Introduction to TemplatesTemplate Declaration SyntaxThe Different Types of Template DeclarationsTemplate ClassesTemplate Instantiation and SpecializationTemplate and Type SafetyDeclaring Templates with Multiple ParametersDeclaring Templates with Default ParametersA Template SampleUsing Templates in Practical C++ ProgrammingSummaryQ&AWorkshopQuizExercises
III. Learning the Standard Template Library (STL)
16. An Introduction to the Standard Template Library
STL ContainersSequential ContainersAssociative ContainersChoosing the Right ContainerSTL IteratorsSTL AlgorithmsThe Interaction Between Containers and Algorithms Using IteratorsSummaryQ&AWorkshopQuiz
17. The STL string Class
The Need for String Manipulation ClassesWorking with the STL string ClassInstantiating the STL string and Making CopiesAccessing a string and Its ContentsString ConcatenationFinding a Character or Substring in a stringTruncating an STL stringString ReversalString Case ConversionTemplate-Based Implementation of an STL stringSummaryQ&AWorkshopQuizExercises
18. STL Dynamic Array Classes
The Characteristics of std::vectorTypical Vector OperationsInstantiating a vectorInserting Elements in a vectorAccessing Elements in a vectorRemoving Elements from a vectorUnderstanding size() and capacity()The STL deque ClassSummaryQ&AWorkshopQuizExercises
19. STL list
The Characteristics of a std::listBasic list OperationsInstantiating a std::list ObjectInserting Elements at the Front of the listInserting Elements at the Back of the listInserting at the Middle of the listErasing Elements in a listReversing and Sorting Elements in a listReversing ElementsSorting ElementsSummaryQ&AWorkshopQuizExercises
20. STL set and multiset
An IntroductionBasic STL set and multiset OperationsInstantiating a std::set ObjectInserting Elements in an STL set or multisetFinding Elements in an STL set or multisetErasing Elements in an STL set or multisetPros and Cons of Using STL set and multisetSummaryQ&AWorkshopQuizExercises
21. STL map and multimap
A Brief IntroductionBasic STL map and multimap OperationsInstantiating a std::map ObjectInserting Elements in an STL map or multimapFinding Elements in an STL map or multimapErasing Elements from an STL map or multimapSupplying a Custom Sort PredicateSummaryQ&AWorkshopQuizExercises
IV. More STL
22. Understanding Function Objects
The Concept of Function Objects and PredicatesTypical Applications of Function ObjectsUnary FunctionsUnary PredicateBinary FunctionsBinary PredicateSummaryQ&AWorkshopQuizExercises
23. STL Algorithms
What Are STL Algorithms?Classification of STL AlgorithmsNonmutating AlgorithmsMutating AlgorithmsUsage of STL AlgorithmsCounting and Finding ElementsSearching for an Element or a Range in a CollectionInitializing Elements in a Container to a Specific ValueProcessing Elements in a Range Using for_eachPerforming Transformations on a Range Using std::transformCopy and Remove OperationsReplacing Values and Replacing Element Given a ConditionSorting and Searching in a Sorted Collection, and Erasing DuplicatesPartitioning a RangeInserting Elements in a Sorted CollectionSummaryQ&AWorkshopQuizExercises
24. Adaptive Containers: stack and queue
The Behavioral Characteristics of Stacks and QueuesStacksQueuesUsing the STL stack ClassInstantiating the StackStack Member FunctionsUsing the STL queue ClassInstantiating the QueueMember Functions of a queueUsing the STL Priority QueueInstantiating the priority_queue ClassMember Functions of priority_queueSummaryQ&AWorkshopQuizExercises
25. Working with Bit Flags Using STL
The bitset ClassInstantiating the std::bitsetUsing std::bitset and Its Membersstd:bitset Operatorsstd::bitset Member MethodsThe vector<bool>Instantiating a vector<bool>Using the vector<bool>SummaryQ&AWorkshopQuizExercises
V. Advanced C++ Concepts
26. Understanding Smart Pointers
What Are Smart Pointers?What Is the Problem with Using Conventional (Raw) Pointers?How Do Smart Pointers Help?How Are Smart Pointers Implemented?Types of Smart PointersDeep CopyCopy on Write MechanismReference Counted Smart PointersReference-Linked Smart PointersDestructive CopyUsing the std::auto_ptrPopular Smart Pointer LibrariesSummaryQ&AWorkshopQuizExercises
27. Working with Streams
Overview of StreamsEncapsulation of Data FlowUnderstanding BufferingStreams and BuffersStandard I/O ObjectsRedirection of the Standard StreamsInput Using cinInputting StringsString ProblemsThe cin Return ValueOther Member Functions of cinSingle Character InputUsing get() with No ParametersUsing get() with a Character Reference ParameterGetting Strings from Standard InputUsing cin.ignore()Peeking At and Returning Characters: peek() and putback()Outputting with coutFlushing the OutputFunctions for Doing OutputWriting Characters with put()Writing More with write()Manipulators, Flags, and Formatting InstructionsUsing cout.width()Setting the Fill CharactersManaging the State of Output: Set FlagsStreams Versus the printf() FunctionFile Input and OutputUsing the ofstreamCondition StatesOpening Files for Input and OutputChanging the Default Behavior of ofstream on OpenBinary Versus Text FilesCommand-Line ProcessingSummaryQ&AWorkshopQuizExercises
28. Exception Handling
Bugs, Errors, Mistakes, and Code RotExceptional CircumstancesThe Idea Behind ExceptionsThe Parts of Exception HandlingCausing Your Own ExceptionsCreating an Exception ClassPlacing try Blocks and catch BlocksHow Catching Exceptions WorkUsing More Than One catch SpecificationException HierarchiesData in Exceptions and Naming Exception ObjectsExceptions and TemplatesExceptions Without ErrorsBugs and DebuggingBreakpointsWatch PointsExamining MemoryAssemblerSummaryQ&AWorkshopQuizExercises
29. Tapping Further into the Preprocessor
The Preprocessor and the CompilerThe #define Preprocessor DirectiveUsing #define for ConstantsUsing #define for TestsThe #else Precompiler CommandInclusion and Inclusion GuardsString ManipulationStringizingConcatenationPredefined MacrosThe assert() MacroDebugging with assert()Using assert() Versus ExceptionsSide EffectsClass InvariantsPrinting Interim ValuesBit TwiddlingOperator ANDOperator OROperator Exclusive ORThe Complement OperatorSetting BitsClearing BitsFlipping BitsBit FieldsProgramming StyleIndentingBracesLong Lines and Function LengthStructuring switch StatementsProgram TextNaming IdentifiersSpelling and Capitalization of NamesCommentsSetting Up AccessClass Definitionsinclude FilesUsing assert()Making Items Constant with constNext Steps in Your C++ DevelopmentWhere to Get Help and AdviceRelated C++ Topics: Managed C++, C#, and Microsoft’s .NETSummaryQ&AWorkshopQuizExercises
Appendixes
A. Working with Numbers: Binary and Hexadecimal
Using Other BasesConverting to Different BasesBinaryWhy Base 2?Bits, Bytes, and NybblesWhat’s a KB?Binary NumbersHexadecimal
B. C++ Keywords
C. Operator Precedence
D. Answers
Lesson 1, “Getting Started”QuizExercisesLesson 2, “The Anatomy of a C++ Program”QuizExercisesLesson 3, “Using Variables, Declaring Constants”QuizExercisesLesson 4, “Managing Arrays and Strings”QuizExercisesLesson 5, “Working with Expressions, Statements, and Operators”QuizExercisesLesson 6, “Organizing Code with Functions”QuizExercisesLesson 7, “Controlling Program Flow”QuizExercisesLesson 8, “Pointers Explained”QuizExercisesLesson 9, “Exploiting References”QuizExercisesLesson 10, “Classes and Objects”QuizExercisesLesson 11, “Implementing Inheritance”QuizExercisesLesson 12, “Polymorphism”QuizExercisesLesson 13, “Operator Types and Operator Overloading”QuizExercisesLesson 14, “Casting Operators”QuizLesson 15, “An Introduction to Macros and Templates”QuizExercisesLesson 16, “An Introduction to the Standard Template Library”QuizLesson 17, “The STL string Class”QuizExercisesLesson 18, “STL Dynamic Array Classes”QuizExercisesLesson 19, “STL list”QuizExercisesLesson 20, “STL set and multiset”QuizExercisesLesson 21, “STL map and multimap”QuizExercisesLesson 22, “Understanding Function Objects”QuizExercisesLesson 23, “STL Algorithms”QuizExercisesLesson 24, “Adaptive Containers: stack and queue”QuizExercisesLesson 25, “Working with Bit Flags Using STL”QuizExercisesLesson 26, “Understanding Smart Pointers”QuizExercisesLesson 27, “Working with Streams”QuizExercisesLesson 28, “Exception Handling”QuizExercisesLesson 29, “Tapping Further into the Preprocessor”QuizExercises
Inside Back Cover

Overview

Sams Teach Yourself C++ in One Hour a Day

Jesse Liberty

Siddhartha Rao

Bradley Jones

The Sixth Edition of Sams Teach Yourself C++ in 21 Days

More than 250,000 sold!

In just one hour a day, you’ll have all the skills you need to begin programming in C++. With this complete tutorial, you’ll quickly master the basics and then move on to more advanced features and concepts:

Master the fundamentals of C++ and object-oriented programming

Learn some of the more advanced features of C++

Learn the Standard Template Library and the containers and algorithms used in most real-world C++ applications

Learn how to build effective programs in C++ with hands-on exercises

Get expert tips on implementing C++ in the corporate environment

Learn on your own time, at your own pace

No previous programming experience required

Learn C++ and object-oriented design, programming, and analysis

Write fast and powerful C++ programs, compile the source code, and create executable files

Understand the latest ANSI standard

Use the Standard Template Library’s algorithms and containers to write feature-rich yet stable C++ applications

Develop sophisticated programming techniques with functions, arrays, variables, and smart pointers

Learn to expand your program’s power with inheritance and polymorphism

Master the features of C++ by learning from programming experts

Works with all ANSI C++ compilers

Jesse Liberty is the author of numerous books on software development, including best-selling titles on C++ and .NET. He is the president of Liberty Associates, Inc., where he provides custom programming, consulting, and training.

Siddhartha Rao, Microsoft MVP for Visual C++, has experience in programming driver and application software using C++. He is an expert in the Windows programming arena and works for a German software giant. He also moderates CodeGuru.com, a vibrant online programming community.

Bradley Jones, Microsoft MVP for Visual C++, runs a number of software development sites including Developer.com, CodeGuru.com, DevX, VBForums, Gamelan, and other JupiterWeb-owned sites.

Category: Programming

Covers: C++

User Level: Beginning–Intermediate

Register your book at informit.com/register for access to source code, example files, updates, and corrections as they become available.

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

Sams Teach Yourself C++ in One Hour a Day, Seventh Edition

Publisher Resources

ISBN: 9780768678598Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills