book

Beginning C++

by Ivor Horton

November 2014

Beginner

632 pages

19h 31m

English

Apress

Read now

Unlock full access

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

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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

Content preview from Beginning C++

CHAPTER 11

Defining Your Own Data Types

In this chapter, I’ll introduce one of the most fundamental tools in the C++ programmer’s toolbox: classes. I’ll also present some ideas that are implicit in object-oriented programming and show how these are applied.

In this chapter you’ll learn:

What the basic principles in objected-oriented programming are
How you define a new data type as a class, and how you can create and use objects of a class type
What class constructors are, and how you define them
What the default constructor is, and how you can supply your own version
What the default copy constructor is
What a friend function is
What privileges ...