book

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

Name: Sams Teach Yourself C++ in One Hour a Day, Eighth Edition
Author: Siddhartha Rao
ISBN: 9780134539553

by Siddhartha Rao

December 2016

Beginner

800 pages

21h 23m

English

Sams

Read now

Unlock full access

About This E-Book
Title Page
Copyright Page
Contents
Dedication
Acknowledgments
About the Author
We Want to Hear from You!
Reader Services
Introduction
Who Should Read This Book?Organization of This BookConventions Used in This BookSample Code for This Book

Part I: The Basics
Lesson 1. Getting Started
A Brief History of C++Connection to CAdvantages of C++Evolution of the C++ StandardWho Uses Programs Written in C++?Programming a C++ ApplicationSteps to Generating an ExecutableAnalyzing Errors and “Debugging”Integrated Development EnvironmentsProgramming Your First C++ ApplicationBuilding and Executing Your First C++ ApplicationUnderstanding Compiler ErrorsWhat’s New in C++?SummaryQ&AWorkshopQuizExercises
Lesson 2. The Anatomy of a C++ Program
Parts of the Hello World ProgramPreprocessor Directive #includeThe Body of Your Program main()Returning a ValueThe Concept of NamespacesComments in C++ CodeFunctions in C++Basic Input Using std::cin and Output Using std::coutSummaryQ&AWorkshopQuizExercises
Lesson 3. Using Variables, Declaring Constants
What Is a Variable?Memory and Addressing in BriefDeclaring Variables to Access and Use MemoryDeclaring and Initializing Multiple Variables of a TypeUnderstanding the Scope of a VariableGlobal VariablesNaming ConventionsCommon Compiler-Supported C++ Variable TypesUsing Type bool to Store Boolean ValuesUsing Type char to Store Character ValuesThe Concept of Signed and Unsigned IntegersSigned Integer Types short, int, long, and long longUnsigned Integer Types unsigned short, unsigned int, unsigned long, and unsigned long longAvoid Overflow Errors by Selecting Correct Data TypesFloating-Point Types float and doubleDetermining the Size of a Variable Using sizeofAvoid Narrowing Conversion Errors by Using List InitializationAutomatic Type Inference Using autoUsing typedef to Substitute a Variable’s TypeWhat Is a Constant?Literal ConstantsDeclaring Variables as Constants Using constConstant Expressions Using constexprEnumerationsDefining Constants Using #defineKeywords You Cannot Use as Variable or Constant NamesSummaryQ&AWorkshopQuizExercises
Lesson 4. Managing Arrays and Strings
What Is an Array?The Need for ArraysDeclaring and Initializing Static ArraysHow Data Is Stored in an ArrayAccessing Data Stored in an ArrayModifying Data Stored in an ArrayMultidimensional ArraysDeclaring and Initializing Multidimensional ArraysAccessing Elements in a Multidimensional ArrayDynamic ArraysC-style Character StringsC++ Strings: Using std::stringSummaryQ&AWorkshopQuizExercises
Lesson 5. Working with Expressions, Statements, and Operators
StatementsCompound Statements or BlocksUsing OperatorsThe Assignment Operator (=)Understanding L-values and R-valuesOperators to Add (+), Subtract (-), Multiply (*), Divide (/), and Modulo Divide (%)Operators to Increment (++) and Decrement (--)To Postfix or to Prefix?Equality Operators (==) and (!=)Relational OperatorsLogical Operations NOT, AND, OR, and XORUsing C++ Logical Operators NOT (!), AND (&&), and OR (||)Bitwise NOT (~), AND (&), OR (|), and XOR (^) OperatorsBitwise Right Shift (>>) and Left Shift (<<) OperatorsCompound Assignment OperatorsUsing Operator sizeof to Determine the Memory Occupied by a VariableOperator PrecedenceSummaryQ&AWorkshopQuizExercises
Lesson 6. Controlling Program Flow
Conditional Execution Using if ... elseConditional Programming Using if ... elseExecuting Multiple Statements ConditionallyNested if StatementsConditional Processing Using switch-caseConditional Execution Using Operator (?:)Getting Code to Execute in LoopsA Rudimentary Loop Using gotoThe while LoopThe do...while LoopThe for LoopThe Range-Based for LoopModifying Loop Behavior Using continue and breakLoops That Don’t End—That Is, Infinite LoopsControlling Infinite LoopsProgramming Nested LoopsUsing Nested Loops to Walk a Multidimensional ArrayUsing Nested Loops to Calculate Fibonacci NumbersSummaryQ&AWorkshopQuizExercises
Lesson 7. Organizing Code with Functions
The Need for FunctionsWhat Is a Function Prototype?What Is a Function Definition?What Is a Function Call, and What Are Arguments?Programming a Function with Multiple ParametersProgramming Functions with No Parameters or No Return ValuesFunction Parameters with Default ValuesRecursion—Functions That Invoke ThemselvesFunctions with Multiple Return StatementsUsing Functions to Work with Different Forms of DataOverloading FunctionsPassing an Array of Values to a FunctionPassing Arguments by ReferenceHow Function Calls Are Handled by the MicroprocessorInline FunctionsAutomatic Return Type DeductionLambda FunctionsSummaryQ&AWorkshopQuizExercises
Lesson 8. Pointers and References Explained
What Is a Pointer?Declaring a PointerDetermining the Address of a Variable Using the Reference Operator (&)Using Pointers to Store AddressesAccess Pointed Data Using the Dereference Operator (*)What Is the sizeof() of a Pointer?Dynamic Memory AllocationUsing Operators new and delete to Allocate and Release Memory DynamicallyEffect of Incrementing and Decrementing Operators (++ and --) on PointersUsing the const Keyword on PointersPassing Pointers to FunctionsSimilarities between Arrays and PointersCommon Programming Mistakes When Using PointersMemory LeaksWhen Pointers Don’t Point to Valid Memory LocationsDangling Pointers (Also Called Stray or Wild Pointers)Checking Whether Allocation Request Using new SucceededPointer Programming Best-PracticesWhat Is a Reference?What Makes References Useful?Using Keyword const on ReferencesPassing Arguments by Reference to FunctionsSummaryQ&AWorkshopQuizExercises
Part II: Fundamentals of Object-Oriented C++ Programming
Lesson 9. Classes and Objects
The Concept of Classes and ObjectsDeclaring a ClassAn Object as an Instance of a ClassAccessing Members Using the Dot Operator (.)Accessing Members Using the Pointer Operator (->)Keywords public and privateAbstraction of Data via Keyword privateConstructorsDeclaring and Implementing a ConstructorWhen and How to Use ConstructorsOverloading ConstructorsClass Without a Default ConstructorConstructor Parameters with Default ValuesConstructors with Initialization ListsDestructorDeclaring and Implementing a DestructorWhen and How to Use a DestructorCopy ConstructorShallow Copying and Associated ProblemsEnsuring Deep Copy Using a Copy ConstructorMove Constructors Help Improve PerformanceDifferent Uses of Constructors and the DestructorClass That Does Not Permit CopyingSingleton Class That Permits a Single InstanceClass That Prohibits Instantiation on the StackUsing Constructors to Convert Typesthis Pointersizeof() a ClassHow struct Differs from classDeclaring a friend of a classunion: A Special Data Storage MechanismDeclaring a UnionWhere Would You Use a union?Using Aggregate Initialization on Classes and Structsconstexpr with Classes and ObjectsSummaryQ&AWorkshopQuizExercises
Lesson 10. Implementing Inheritance
Basics of InheritanceInheritance and DerivationC++ Syntax of DerivationAccess Specifier Keyword protectedBase Class Initialization—Passing Parameters to the Base ClassDerived Class Overriding Base Class’s MethodsInvoking Overridden Methods of a Base ClassInvoking Methods of a Base Class in a Derived ClassDerived Class Hiding Base Class’s MethodsOrder of ConstructionOrder of DestructionPrivate InheritanceProtected InheritanceThe Problem of SlicingMultiple InheritanceAvoiding Inheritance Using finalSummaryQ&AWorkshopQuizExercises
Lesson 11. Polymorphism
Basics of PolymorphismNeed for Polymorphic BehaviorPolymorphic Behavior Implemented Using Virtual FunctionsNeed for Virtual DestructorsHow Do virtual Functions Work? Understanding the Virtual Function TableAbstract Base Classes and Pure Virtual FunctionsUsing virtual Inheritance to Solve the Diamond ProblemSpecifier Override to Indicate Intention to OverrideUse final to Prevent Function OverridingVirtual Copy Constructors?SummaryQ&AWorkshopQuizExercises
Lesson 12. Operator Types and Operator Overloading
What Are Operators in C++?Unary OperatorsTypes of Unary OperatorsProgramming a Unary Increment/Decrement OperatorProgramming Conversion OperatorsProgramming Dereference Operator (*) and Member Selection Operator (->)Binary OperatorsTypes of Binary OperatorsProgramming Binary Addition (a+b) and Subtraction (a-b) OperatorsImplementing Addition Assignment (+=) and Subtraction Assignment (-=) OperatorsOverloading Equality (==) and Inequality (!=) OperatorsOverloading <, >, <=, and >= OperatorsOverloading Copy Assignment Operator (=)Subscript Operator ([])Function Operator ()Move Constructor and Move Assignment Operator for High Performance ProgrammingThe Problem of Unwanted Copy StepsDeclaring a Move Constructor and Move Assignment OperatorUser Defined LiteralsOperators That Cannot Be OverloadedSummaryQ&AWorkshopQuizExercises
Lesson 13. Casting Operators
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&AWorkshopQuizExercises
Lesson 14. An Introduction to Macros and Templates
The Preprocessor and the CompilerUsing Macro #define to Define ConstantsUsing Macros for Protection against Multiple InclusionUsing #define to Write Macro FunctionsWhy All the Parentheses?Using Macro assert to Validate ExpressionsAdvantages and Disadvantages of Using Macro FunctionsAn Introduction to TemplatesTemplate Declaration SyntaxThe Different Types of Template DeclarationsTemplate FunctionsTemplates and Type SafetyTemplate ClassesDeclaring Templates with Multiple ParametersDeclaring Templates with Default ParametersSample Template class<> HoldsPairTemplate Instantiation and SpecializationTemplate Classes and static MembersVariable Templates, Also Called Variadic TemplatesUsing static_assert to Perform Compile-Time ChecksUsing Templates in Practical C++ ProgrammingSummaryQ&AWorkshopQuizExercises
Part III: Learning the Standard Template Library (STL)
Lesson 15. An Introduction to the Standard Template Library
STL ContainersSequential ContainersAssociative ContainersContainer AdaptersSTL IteratorsSTL AlgorithmsThe Interaction between Containers and Algorithms Using IteratorsUsing Keyword auto to Let Compiler Define TypeChoosing the Right ContainerSTL String ClassesSummaryQ&AWorkshopQuiz
Lesson 16. The STL String Class
The Need for String Manipulation ClassesWorking with the STL String ClassInstantiating the STL String and Making CopiesAccessing Character Contents of a std::stringConcatenating One String to AnotherFinding a Character or Substring in a StringTruncating an STL stringString ReversalString Case ConversionTemplate-Based Implementation of an STL StringC++14 operator ""s in std::stringSummaryQ&AWorkshopQuizExercises
Lesson 17. STL Dynamic Array Classes
The Characteristics of std::vectorTypical Vector OperationsInstantiating a VectorInserting Elements at the End Using push_back()List InitializationInserting Elements at a Given Position Using insert()Accessing Elements in a Vector Using Array SemanticsAccessing Elements in a Vector Using Pointer SemanticsRemoving Elements from a VectorUnderstanding the Concepts of Size and CapacityThe STL deque ClassSummaryQ&AWorkshopQuizExercises
Lesson 18. STL list and forward_list
The Characteristics of a std::listBasic list OperationsInstantiating a std::list ObjectInserting Elements at the Front or Back of the ListInserting at the Middle of the ListErasing Elements from the ListReversing and Sorting Elements in a ListReversing Elements Using list::reverse()Sorting ElementsSorting and Removing Elements from a list That Contains Instances of a classstd::forward_list Introduced in C++11SummaryQ&AWorkshopQuizExercises
Lesson 19. STL Set Classes
An Introduction to STL Set ClassesBasic STL set and multiset OperationsInstantiating a std::set ObjectInserting Elements in a set or multisetFinding Elements in an STL set or multisetErasing Elements in an STL set or multisetPros and Cons of Using STL set and multisetSTL Hash Set Implementation std::unordered_set and std::unordered_multisetSummaryQ&AWorkshopQuizExercises
Lesson 20. STL Map Classes
An Introduction to STL Map ClassesBasic std::map and std::multimap OperationsInstantiating a std::map or std::multimapInserting Elements in an STL map or multimapFinding Elements in an STL mapFinding Elements in an STL multimapErasing Elements from an STL map or multimapSupplying a Custom Sort PredicateSTL’s Hash Table-Based Key-Value ContainerHow Hash Tables WorkUsing unordered_map and unordered_multimapSummaryQ&AWorkshopQuizExercises
Part IV: More STL
Lesson 21. Understanding Function Objects
The Concept of Function Objects and PredicatesTypical Applications of Function ObjectsUnary FunctionsUnary PredicateBinary FunctionsBinary PredicateSummaryQ&AWorkshopQuizExercises
Lesson 22. Lambda Expressions
What Is a Lambda Expression?How to Define a Lambda ExpressionLambda Expression for a Unary FunctionLambda Expression for a Unary PredicateLambda Expression with State via Capture Lists [...]The Generic Syntax of Lambda ExpressionsLambda Expression for a Binary FunctionLambda Expression for a Binary PredicateSummaryQ&AWorkshopQuizExercises
Lesson 23. STL Algorithms
What Are STL Algorithms?Classification of STL AlgorithmsNon-Mutating AlgorithmsMutating AlgorithmsUsage of STL AlgorithmsFinding Elements Given a Value or a ConditionCounting Elements Given a Value or a ConditionSearching for an Element or a Range in a CollectionInitializing Elements in a Container to a Specific ValueUsing std::generate() to Initialize Elements to a Value Generated at RuntimeProcessing Elements in a Range Using for_each()Performing Transformations on a Range Using std::transform()Copy 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
Lesson 24. Adaptive Containers: Stack and Queue
The Behavioral Characteristics of Stacks and QueuesStacksQueuesUsing the STL stack ClassInstantiating the StackStack Member FunctionsInsertion and Removal at Top Using push() and pop()Using the STL queue ClassInstantiating the QueueMember Functions of a queueInsertion at End and Removal at the Beginning of queue via push() and pop()Using the STL Priority QueueInstantiating the priority_queue ClassMember Functions of priority_queueInsertion at the End and Removal at the Beginning of priority_queue via push() and pop()SummaryQ&AWorkshopQuizExercises
Lesson 25. Working with Bit Flags Using STL
The bitset ClassInstantiating the std::bitsetUsing std::bitset and Its MembersUseful Operators Featured in std::bitsetstd::bitset Member MethodsThe vector<bool>Instantiating vector<bool>vector<bool> Functions and OperatorsSummaryQ&AWorkshopQuizExercises
Part V: Advanced C++ Concepts
Lesson 26. Understanding Smart Pointers
What Are Smart Pointers?The Problem with Using Conventional (Raw) PointersHow 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::unique_ptrPopular Smart Pointer LibrariesSummaryQ&AWorkshopQuizExercises
Lesson 27. Using Streams for Input and Output
Concept of StreamsImportant C++ Stream Classes and ObjectsUsing std::cout for Writing Formatted Data to ConsoleChanging Display Number Formats Using std::coutAligning Text and Setting Field Width Using std::coutUsing std::cin for InputUsing std::cin for Input into a Plain Old Data TypeUsing std::cin::get for Input into char* BufferUsing std::cin for Input into a std::stringUsing std::fstream for File HandlingOpening and Closing a File Using open() and close()Creating and Writing a Text File Using open() and operator<<Reading a Text File Using open() and operator>>Writing to and Reading from a Binary FileUsing std::stringstream for String ConversionsSummaryQ&AWorkshopQuizExercises
Lesson 28. Exception Handling
What Is an Exception?What Causes Exceptions?Implementing Exception Safety via try and catchUsing catch(...) to Handle All ExceptionsCatching Exception of a TypeThrowing Exception of a Type Using throwHow Exception Handling WorksClass std::exceptionYour Custom Exception Class Derived from std::exceptionSummaryQ&AWorkshopQuizExercises
Lesson 29. Going Forward
What’s Different in Today’s Processors?How to Better Use Multiple CoresWhat Is a Thread?Why Program Multithreaded Applications?How Can Threads Transact Data?Using Mutexes and Semaphores to Synchronize ThreadsProblems Caused by MultithreadingWriting Great C++ CodeC++17: Expected Featuresif and switch Support InitializersCopy Elision Guaranteestd::string_view Avoids Allocation Overheadsstd::variant As a Typesafe Alternative to a unionConditional Code Compilation Using if constexprImproved Lambda ExpressionsAutomatic Type Deduction for Constructorstemplate<auto>Learning C++ Doesn’t Stop Here!Online DocumentationCommunities for Guidance and HelpSummaryQ&AWorkshopQuiz
Part VI: Appendixes
Appendix A. Working with Numbers: Binary and Hexadecimal
Decimal Numeral SystemBinary Numeral SystemWhy Do Computers Use Binary?What Are Bits and Bytes?How Many Bytes Make a Kilobyte?Hexadecimal Numeral SystemWhy Do We Need Hexadecimal?Converting to a Different BaseThe Generic Conversion ProcessConverting Decimal to BinaryConverting Decimal to Hexadecimal
Appendix B. C++ Keywords
Appendix C. Operator Precedence
Appendix D. ASCII Codes
ASCII Table of Printable Characters
Appendix E. Answers
Answers for Lesson 1QuizExercisesAnswers for Lesson 2QuizExercisesAnswers for Lesson 3QuizExercisesAnswers for Lesson 4QuizExercisesAnswers for Lesson 5QuizExercisesAnswers for Lesson 6QuizExercisesAnswers for Lesson 7QuizExercisesAnswers for Lesson 8QuizExercisesAnswers for Lesson 9QuizExercisesAnswers for Lesson 10QuizExercisesAnswers for Lesson 11QuizExercisesAnswers for Lesson 12QuizExercisesAnswers for Lesson 13QuizExercisesAnswers for Lesson 14QuizExercisesAnswers for Lesson 15QuizAnswers for Lesson 16QuizExercisesAnswers for Lesson 17QuizExercisesAnswers for Lesson 18QuizExercisesAnswers for Lesson 19QuizExercisesAnswers for Lesson 20QuizExercisesAnswers for Lesson 21QuizExercisesAnswers for Lesson 22QuizExercisesAnswers for Lesson 23QuizExercisesAnswers for Lesson 24QuizExercisesAnswers for Lesson 25QuizExercisesAnswers for Lesson 26QuizExercisesAnswers for Lesson 27QuizExercisesAnswers for Lesson 28QuizExercisesAnswers for Lesson 29Quiz
Index
Code Snippets

Content preview from Sams Teach Yourself C++ in One Hour a Day, Eighth Edition

Lesson 18. STL `list` and `forward_list`

The Standard Template Library (STL) supplies the programmer with a doubly linked list in the form of template class std::list. The main advantage of a linked list is in fast and constant time insertion and removal of elements. Starting with C++11, you can also use a singly linked list in the form of std::forward_list that can be traversed only in one direction.

In this lesson, you learn

How to instantiate list and forward_list

How to use the STL list classes, including insertion and removal

How to reverse and ...

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: 9780134539553Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

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

by Siddhartha Rao

Lesson 18. STL `list` and `forward_list`

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.