book

Advanced C++

by Gazihan Alankus, Olena Lizina, Rakesh Mane, Vivek Nagarajan, Brian Price

October 2019

Intermediate to advanced

762 pages

14h 7m

English

Packt Publishing

Read now

Unlock full access

About the BookAbout the AuthorsLearning ObjectivesAudienceApproachHardware RequirementsSoftware RequirementsInstallation and SetupInstalling the Code BundleAdditional Resources
IntroductionManaging C++ ProjectsThe Code-Build-Test-Run LoopBuilding a CMake ProjectExercise 1: Using CMake to Generate Ninja Build FilesImporting a CMake Project into Eclipse CDTExercise 2: Importing the CMake File into Eclipse CDTExercise 3: Adding New Source Files to CMake and Eclipse CDTActivity 1: Adding a New Source-Header File Pair to the ProjectUnit TestingPreparing for the Unit TestsExercise 4: Preparing Our Project for Unit TestingBuilding, Running, and Writing Unit TestsExercise 5: Building and Running TestsExercise 6: Testing the Functionality of CodeActivity 2: Adding a New Class and Its TestUnderstanding Compilation, Linking, and Object File ContentsCompilation and Linking StepsExercise 7: Identifying Build StepsThe Linking StepDiving Deeper: Viewing Object FilesExercise 8: Exploring Compiled CodeDebugging C++ CodeExercise 9: Debugging with Eclipse CDTWriting Readable CodeIndentation and FormattingUse Meaningful Names as IdentifiersKeeping Algorithms Clear and SimpleExercise 10: Making Code ReadableActivity 3: Making Code More ReadableSummary
IntroductionC++ TypesC++ Fundamental TypesC++ LiteralsSpecifying Types – VariablesExercise 1: Declaring Variables and Exploring SizesSpecifying Types – FunctionsExercise 2: Declaring Functions Pointer TypesExercise 3: Declaring and Using Pointers Creating User TypesEnumerationsExercise 4: Enumerations – Old and New SchoolStructures and ClassesFraction ClassConstructors, Initialization, and DestructorsClass Special Member FunctionsImplicit Versus Explicit ConstructorsClass Special Member Functions – Compiler Generation RulesDefaulting and Deleting Special Member FunctionsRule of Three/Five and Rule of ZeroConstructors – Initializing the ObjectExercise 5: Declaring and Initializing FractionsValues Versus References and ConstExercise 6: Declaring and Using Reference TypesImplementing Standard OperatorsImplementing the Output Stream Operator (<<)Structuring Our CodeExercise 7: Adding Operators to the Fraction ClassFunction OverloadingClasses, Structs, and UnionsActivity 1: Graphics ProcessingSummary
IntroductionInheritance, Polymorphism, and InterfacesInheritance and Access SpecifiersAbstract Classes and InterfacesExercise 1: Implementing Game Characters with PolymorphismClasses, Structs, and Unions RevisitedVisibility, Lifetime, and AccessNamespacesTemplates – Generic ProgrammingWhat is Generic Programming?Introducing C++ TemplatesC++ Pre-Packaged TemplatesType Aliases – typedef and usingExercise 2: Implementing AliasesTemplates – More than Generic ProgrammingSubstitution Failure Is Not An Error – SFINAEFloating-Point RepresentationsConstexpr if ExpressionsNon-Type Template ArgumentsExercise 3: Implementing Stringify – specialization Versus constexprFunction Overloading RevisitedTemplate Type DeductionDisplaying the Deduced TypesTemplate Type Deduction – the DetailsSFINAE Expression and Trailing Return TypesClass TemplatesExercise 4: Writing a Class TemplateActivity 1: Developing a Generic "contains" Template FunctionSummary
IntroductionVariable Scope and LifetimeExceptions in C++The Need for ExceptionsStack UnwindingExercise 1: Implementing exceptions in Fraction and StackWhat Happens When an Exception is Thrown?Throw-by-Value or Throw-by-PointerStandard Library ExceptionsCatching ExceptionsExercise 2: Implementing Exception HandlersCMake Generator ExpressionsException Usage GuidelinesResource Management (in an Exceptional World) Resource Acquisition Is InitializationExercise 3: Implementing RAII for Memory and File HandlesSpecial Coding TechniquesC++ doesn't Need finallyRAII and the STLWho Owns This Object?Temporary ObjectsMove SemanticsImplementing a Smart PointerSTL Smart Pointersstd::unique_ptr std::shared_ptr std::weak_ptrSmart Pointers and Calling FunctionsExercise 4: Implementing RAII with STL Smart PointersRule of Zero/Five – A Different PerspectiveActivity 1: Implementing Graphics Processing with RAII and MoveWhen is a Function Called?Which Function to CallIdentifiersNamesName lookupArgument-Dependent LookupCaveat Emptor Exercise 5: Implementing Templates to Prevent ADL IssuesImplicit ConversionExplicit – Preventing Implicit Conversion Contextual ConversionExercise 6: Implicit and Explicit Conversions Activity 2: Implementing classes for Date CalculationsSummary
IntroductionThe Pointer to Implementation (PIMPL) IdiomLogical and Physical DependenciesThe Pointer to Implementation (PIMPL) IdiomAdvantages and Disadvantages of PIMPLImplementing PIMPL with unique_ptr<>unique_ptr<> PIMPL Special FunctionsExercise 1: Implementing a Kitchen with unique_ptr<>Function Objects and Lambda ExpressionsFunction PointersWhat is a Function Object?Exercise 2: Implementing function objectsstd::function<> templateExercise 3: Implementing callbacks with std::functionWhat is a Lambda Expression?Capturing data into LambdasExercise 4: Implementing LambdasVariadic TemplatesActivity 1: Implement a multicast event handler Summary
IntroductionSynchronous, Asynchronous, and Threaded ExecutionConcurrencyParallelismSynchronous ExecutionAsynchronous ExecutionExercise 1: Creating Threads in a Different WayReview Synchronization, Data Hazards, and Race ConditionsExercise 2: Writing an Example of Race ConditionsData HazardsRAW DependencyWAR DependencyWAW DependencyResource SynchronizationEvent SynchronizationDeadlockMove Semantics for Multithreading ClosuresExercise 3: Moving Objects to a Thread FunctionExercise 4: Creating and Working with an STL Container of Threads Futures, Promises, and AsyncExercise 5: Synchronization with Future ResultsActivity 1: Creating a Simulator to Model the Work of the Art GallerySummary
IntroductionReviewing the I/O Portion of the Standard LibraryPredefined Standard Stream ObjectsExercise 1: Overriding the Left Shift Operator, <<, for User-Defined TypesFile I/O Implementation ClassesExercise 2: Reading and Writing User-Defined Data Types to a FileString I/O ImplementationExercise 3: Creating a Function for Replacement Words in a StringI/O ManipulatorsI/O Manipulators for Changing the Numeric Base of the Stream Exercise 4: Displaying Entered Numbers in Different Numeric BasesI/O Manipulators for Floating-Point FormattingExercise 5: Displaying Entered Floating-Point Numbers with Different FormattingI/O Manipulators for Boolean FormattingI/O Manipulators for Field Width and Fill ControlI/O Manipulators for Other Numeric FormattingI/O Manipulators for Whitespace ProcessingMaking Additional StreamsHow to Make an Additional Stream – CompositionExercise 6: Composing the Standard Stream Object in the User-Defined ClassHow to Make an Additional Stream – InheritanceExercise 7: Inheriting the Standard Stream ObjectLeveraging Asynchronous I/OAsynchronous I/O on Windows PlatformsAsynchronous I/O on Linux PlatformsExercise 8: Asynchronously Reading from a File in LinuxAsynchronous Cross-Platform I/O LibrariesInteraction of Threads and I/OExercise 9: Developing a Thread-Safe Wrapper for std::coutUsing MacrosActivity 1: The Logging System for The Art Gallery SimulatorSummary
IntroductionAssertionsExercise 1: Writing and Testing Our First AssertionStatic AssertionsExercise 2: Testing Static AssertionsUnderstanding Exception HandlingExercise 3: Performing Exception Handling Unit Testing and Mock TestingExercise 4: Creating Our First Unit Test CaseUnit Testing Using Mock ObjectsExercise 5: Creating Mock ObjectsBreakpoints, Watchpoints, and Data VisualizationWorking with the Stack Data StructureActivity 1: Checking the Accuracy of the Functions Using Test Cases and Understanding Test-Driven Development (TDD)Summary
IntroductionPerformance MeasurementManual EstimationStudying Generated Assembly CodeManual Execution TimingExercise 1: Timing a Program's ExecutionTiming Programs without Side EffectsSource Code InstrumentationExercise 2: Writing a Code Timer ClassRuntime ProfilingExercise 3: Using perf to Profile ProgramsOptimization StrategiesCompiler-Based OptimizationLoop UnrollingExercise 4: Using Loop Unrolling OptimizationsProfile Guided OptimizationExercise 5: Using Profile Guided OptimizationParallelizationExercise 6: Using Compiler ParallelizationSource Code Micro OptimizationsUsing the std::vector Container EfficientlyExercise 7: Optimizing Vector GrowthShort-Circuit Logical OperatorsExercise 8: Optimizing Logical OperatorsBranch PredictionExercise 9: Optimization for Branch PredictionFurther OptimizationsCache Friendly CodeExercise 10: Exploring the Effect of Caches on Data StructuresExercise 11: Measuring the Impact of Memory AccessCachingPrefetchingEffects of Caching on AlgorithmsOptimizing for Cache-FriendlinessExercise 12: Exploring the Cost of Heap AllocationsStruct of Arrays PatternExercise 13: Using the Struct of Arrays PatternAlgorithmic OptimizationsExercise 14: Optimizing a Word Count ProgramActivity 1: Optimizing a Spell Check AlgorithmSummary

1. Anatomy of Portable C++ SoftwareActivity 1: Adding a New Source-Header File Pair to the ProjectActivity 2: Adding a New Class and Its TestActivity 3: Making Code More Readable2A. No Ducks Allowed – Types and DeductionActivity 1: Graphics Processing2B. No Ducks Allowed – Templates and DeductionActivity 1: Developing a Generic "contains" Template Function3. The Distance between Can and Should – Objects, Pointers and InheritanceActivity 1: Implementing Graphics Processing with RAII and MoveActivity 2: Implementing classes for Date Calculations4. Separation of Concerns - Software Architecture, Functions, Variadic TemplatesActivity 1: Implement a multicast event handler 5. The Philosophers' Dinner – Threads and ConcurrencyActivity 1: Creating a Simulator to Model the Work of the Art Gallery6. Streams and I/OActivity 1 The Logging System for The Art Gallery Simulator7. Everybody Falls, It's How You Get Back Up – Testing and DebuggingActivity 1: Checking the Accuracy of the Functions Using Test Cases and Understanding Test-Driven Development (TDD)8. Need for Speed – Performance and OptimizationActivity 1: Optimizing a Spell Check Algorithm

Content preview from Advanced C++

3. No Leaks Allowed - Exceptions and Resources

Learning Objectives

By the end of this chapter, you will be able to:

Develop classes to manage resources
Develop exception-robust code so that the resources do not leak through RAII
Implement classes that can transfer resource ownership through move semantics
Implement classes that control implicit conversion

In this chapter, you will learn how to use a class to manage resources, protect against leaks, and prevent copying a large amount of data.

Introduction

In Chapter 2A, No Ducks Allowed – Types, and Deduction, we briefly touched on some concepts, such as smart pointers and move semantics. In this chapter, we'll be exploring them further. It turns out that these topics are very closely ...