book

Beginning C++

Name: Beginning C++
Author: Ivor Horton
ISBN: 9781484200070

by Ivor Horton

November 2014

Beginner

632 pages

19h 31m

English

Apress

Read now

Unlock full access

Cover
Title
Copyright
Dedication
Contents at a Glance
Contents
About the Author
About the Technical Reviewer
Introduction
Chapter 1: Basic Ideas
Modern C++C++ Program ConceptsComments and WhitespacePreprocessing Directives and Header FilesFunctionsStatementsData Input and Outputreturn StatementsNamespacesNames and KeywordsClasses and ObjectsTemplatesProgram FilesStandard LibrariesCode Presentation StyleCreating an ExecutableRepresenting NumbersBinary NumbersHexadecimal NumbersNegative Binary NumbersOctal ValuesBig-Endian and Little-Endian SystemsFloating-Point NumbersRepresenting CharactersASCII CodesUCS and UnicodeC++ Source CharactersTrigraph SequencesEscape SequencesProcedural and Object-Oriented ProgrammingSummary

Chapter 2: Introducing Fundamental Types of Data
Variables, Data, and Data TypesDefining Integer VariablesDefining Variables with Fixed ValuesInteger LiteralsDecimal Integer LiteralsCalculations with IntegersMore on Assignment OperationsThe op= Assignment Operatorsusing Declarations and DirectivesThe sizeof OperatorIncrementing and Decrementing IntegersPostfix Increment and Decrement OperationsDefining Floating-Point VariablesFloating-Point LiteralsFloating-Point CalculationsMathematical FunctionsFormatting Stream OutputMixed Expressions and Type ConversionExplicit Type ConversionOld-Style CastsFinding the LimitsWorking with Character VariablesWorking with Unicode CharactersThe auto KeywordLvalues and RvaluesSummary
Chapter 3: Working with Fundamental Data Types
Operator Precedence and AssociativityBitwise OperatorsThe Bitwise Shift OperatorsUsing the Bitwise ANDUsing the Bitwise ORUsing the Bitwise Exclusive OREnumerated Data TypesOld-Style EnumerationsSynonyms for Data TypesThe Lifetime of a VariablePositioning Variable DefinitionsGlobal VariablesStatic VariablesExternal VariablesSummary
Chapter 4: Making Decisions
Comparing Data ValuesApplying the Comparison OperatorsComparing Floating Point ValuesThe if StatementNested if StatementsCode-Neutral Character HandlingThe if-else StatementNested if-else StatementsUnderstanding Nested ifsLogical OperatorsLogical ANDLogical ORLogical NegationThe Conditional OperatorThe switch StatementUnconditional BranchingStatement Blocks and Variable ScopeSummary
Chapter 5: Arrays and Loops
ArraysUsing an ArrayUnderstanding LoopsThe for LoopAvoiding Magic NumbersDefining the Array Size with the Initializer ListDetermining the Size of an ArrayControlling a for Loop with Floating-Point ValuesMore Complex for Loop Control ExpressionsThe Comma OperatorThe Ranged-based for LoopThe while LoopAllocating an Array at RuntimeThe do-while LoopNested LoopsSkipping Loop IterationsBreaking Out of a LoopIndefinite LoopsArrays of CharactersMultidimensional ArraysInitializing Multidimensional ArraysMultidimensional Character ArraysAlternatives to Using an ArrayUsing array<T,N> ContainersUsing std::vector<T> ContainersThe Capacity and Size of a VectorDeleting Elements from a Vector containerSummary
Chapter 6: Pointers and References
What Is a Pointer?The Address-Of OperatorThe Indirection OperatorWhy Use Pointers?Pointers to Type charArrays of PointersConstant Pointers and Pointers to ConstantsPointers and ArraysPointer ArithmeticUsing Pointer Notation with an Array NameDynamic Memory AllocationThe Stack and the HeapUsing the new and delete OperatorsDynamic Allocation of ArraysMember Selection through a PointerHazards of Dynamic Memory AllocationMemory LeaksFragmentation of the Free StoreRaw Pointers and Smart PointersUsing unique_ptr<T> PointersUsing shared_ptr<T> PointersComparing shared_ptr<T> Objectsweak_ptr<T> PointersUnderstanding ReferencesDefining lvalue ReferencesUsing a Reference Variable in a Range-Based for LoopDefining rvalue ReferencesSummary
Chapter 7: Working with Strings
A Better Class of StringDefining string ObjectsOperations with String ObjectsAccessing Characters in a StringAccessing SubstringsComparing StringsSearching StringsSearching a String BackwardsModifying a StringStrings of International CharactersStrings of wchar_t CharactersObjects that contain Unicode StringsRaw String LiteralsSummary
Chapter 8: Defining Functions
Segmenting Your ProgramsFunctions in ClassesCharacteristics of a FunctionDefining FunctionsThe Function BodyFunction DeclarationsPassing Arguments to a FunctionPass-by-ValuePass-by-ReferenceArguments to main()Default Argument ValuesMultiple Default Parameter ValuesReturning Values from a FunctionReturning a PointerReturning a ReferenceInline FunctionsStatic VariablesFunction OverloadingOverloading and Pointer ParametersOverloading and Reference ParametersOverloading and const ParametersOverloading and Default Argument ValuesA Sausage Machine for FunctionsCreating Instances of a Function TemplateExplicit Template ArgumentFunction Template SpecializationFunction Templates and OverloadingFunction Templates with Multiple ParametersNon-Type Template ParametersTrailing Return TypesPointers to FunctionsDefining Pointers to FunctionsRecursionApplying RecursionThe Quicksort AlgorithmThe main() FunctionThe extract_words() FunctionThe swap() FunctionThe sort() functionThe max_word_length() FunctionThe show_words() FunctionSummary
Chapter 9: Lambda Expressions
Introducing Lambda ExpressionsDefining a Lambda ExpressionNaming a Lambda ExpressionPassing a Lambda Expression to a FunctionFunction Templates that Accept Lambda Expression ArgumentsA Function Parameter Type for Lambda ArgumentsUsing the std::function Template TypeThe Capture ClauseCapturing Specific VariablesUsing Lambda Expressions in a TemplateRecursion in Lambda ExpressionsSummary
Chapter 10: Program Files and Preprocessing Directives
Understanding Translation UnitsThe “One Definition” RuleProgram Files and LinkageDetermining Linkage for a NameExternal Namesconst Variables with External LinkagePreprocessing Your Source CodeDefining Preprocessing IdentifiersUndefining an IdentifierIncluding Header FilesPreventing Duplication of Header File ContentsNamespacesThe Global NamespaceDefining a NamespaceApplying using DeclarationsFunctions and NamespacesUnnamed NamespacesNamespace AliasesNested NamespacesLogical Preprocessing DirectivesThe Logical #if DirectiveTesting for Specific Identifier ValuesMultiple Choice Code SelectionStandard Preprocessing MacrosDebugging MethodsIntegrated DebuggersPreprocessing Directives in DebuggingUsing the assert( ) MacroSwitching Off assert() MacrosStatic AssertionsSummary
Chapter 11: Defining Your Own Data Types
Classes and Object-Oriented ProgrammingEncapsulationInheritancePolymorphismTerminologyDefining a ClassConstructorsDefining Constructors Outside the ClassDefault Constructor Parameter ValuesUsing a Constructor Initialization ListUse of the explicit KeywordDelegating ConstructorsThe Copy ConstructorAccessing Private Class MembersFriendsThe Friend Functions of a ClassFriend ClassesThe this PointerReturning this from a Functionconst Objects and const Member FunctionsCasting Away constArrays of Class ObjectsThe Size of a Class ObjectStatic Members of a ClassStatic Data MembersAccessing Static Data MembersA Static Data Member of the Class TypeStatic Function MembersDestructorsPointers and References to Class ObjectsUsing Pointers As Class MembersDefining the Package ClassDefining the Truckload ClassImplementing the Truckload ClassNested ClassesSummary
Chapter 12: Operator Overloading
Implementing Operators for a ClassOperator OverloadingOperators That Can Be OverloadedImplementing an Overloaded OperatorGlobal Operator FunctionsImplementing Full Support for an OperatorImplementing All Comparison Operators in a ClassOperator Function IdiomsDefault Class MembersDefining the DestructorWhen to Define a Copy ConstructorImplementing the Assignment OperatorImplementing Move OperationsOverloading the Arithmetic OperatorsImproving Output OperationsImplementing One Operator in Terms of AnotherOverloading the Subscript OperatorLvalues and the Overloaded Subscript OperatorOverloading Type ConversionsOverloading the Increment and Decrement OperatorsFunction ObjectsSummary
Chapter 13: Inheritance
Classes and Object-Oriented ProgrammingHierarchiesInheritance in ClassesInheritance vs. AggregationDeriving Classesprotected Members of a ClassThe Access Level of Inherited Class MembersChoosing Access Specifiers in Class HierarchiesChanging the Access Specification of Inherited MembersConstructor Operation in a Derived ClassThe Copy Constructor in a Derived ClassThe Default Constructor in a Derived ClassInheriting ConstructorsDestructors Under InheritanceThe Order in Which Destructors Are CalledDuplicate Data Member NamesDuplicate Function Member NamesMultiple InheritanceMultiple Base ClassesInherited Member AmbiguityRepeated InheritanceVirtual Base ClassesConverting Between Related Class TypesSummary
Chapter 14: Polymorphism
Understanding PolymorphismUsing a Base Class PointerCalling Inherited FunctionsVirtual FunctionsDefault Argument Values in Virtual FunctionsVirtual Function Calls with Smart PointersUsing References to Call Virtual FunctionsCalling the Base Class Version of a Virtual FunctionConverting Between Pointers to Class ObjectsDynamic CastsConverting ReferencesDetermining the Polymorphic TypeThe Cost of PolymorphismPure Virtual FunctionsAbstract ClassesIndirect Abstract Base ClassesDestroying Objects Through a PointerVirtual DestructorsSummary
Chapter 15: Runtime Errors and Exceptions
Handling ErrorsUnderstanding ExceptionsThrowing an ExceptionThe Exception Handling ProcessCode That Causes an Exception to Be ThrownNested try BlocksHow It WorksClass Objects as ExceptionsMatching a Catch Handler to an ExceptionHow It WorksCatching Derived Class Exceptions with a Base Class HandlerRethrowing ExceptionsCatching All ExceptionsFunctions That Throw ExceptionsFunction try BlocksFunctions That Don’t Throw ExceptionsConstructor try BlocksExceptions and DestructorsStandard Library ExceptionsThe Exception Class DefinitionsUsing Standard ExceptionsSummary
Chapter 16: Class Templates
Understanding Class TemplatesDefining Class TemplatesTemplate ParametersA Simple Class TemplateDefining Function Members of a Class TemplateInstantiating a Class TemplateStatic Members of a Class TemplateNon-Type Class Template ParametersTemplates for Function Members with Non-Type ParametersArguments for Non-Type ParametersPointers and Arrays as Non-Type ParametersDefault Values for Template ParametersExplicit Template InstantiationSpecial CasesUsing static_assert( ) in a Class TemplateDefining a Class Template SpecializationPartial Template SpecializationChoosing between Multiple Partial SpecializationsFriends of Class TemplatesClass Templates with Nested ClassesFunction Templates for Stack MembersSummary
Chapter 17: File Input and Output
Input and Output in C++Understanding StreamsAdvantages of Using StreamsStream ClassesStandard Stream ObjectsStream Insertion and Extraction OperationsStream ManipulatorsFile StreamsWriting a File in Text ModeReading a File in Text ModeSetting the Stream Open ModeManaging the Current Stream PositionUnformatted Stream OperationsUnformatted Stream InputUnformatted Stream OutputErrors in Stream Input/OutputInput/Output Errors and Exceptions
Stream Operations in Binary Mode
Writing Numeric Data in BinaryFile Read/Write OperationsRandom Access to a FileString StreamsObjects and StreamsUsing the Insertion Operator with ObjectsUsing the Extraction Operator with ObjectsObject I/O in Binary ModeMore Complex Objects in StreamsSummary
Index

Overview

Beginning C++ is a tutorial for beginners in C++ and discusses a subset of C++ that is suitable for beginners. The language syntax corresponds to the C++14 standard. This book is environment neutral and does not presume any specific operating system or program development system. There is no assumption of prior programming knowledge.

All language concepts that are explained in the book are illustrated with working program examples. Most chapters include exercises for you to test your knowledge. Code downloads are provided for examples from the text and solutions to the exercises and there is an additional download for a more substantial project for you to try when you have finished the book.

This book introduces the elements of the C++ standard library that provide essential support for the language syntax that is discussed. While the Standard Template Library (STL) is not discussed to a significant extent, a few elements from the STL that are important to the notion of modern C++ are introduced and applied.

Beginning C++ is based on and supersedes Ivor Hortons previous book, Beginning ANSI C++.

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

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills