book

The C++ Workshop

Name: The C++ Workshop
ISBN: 9781839216626

by Dale Green, Anil Achary, Kurt Guntheroth, Shaun Ross Mitchell

February 2020

Beginner

606 pages

10h 39m

English

Packt Publishing

Read now

Unlock full access

Preface
About the BookAbout the ChaptersConventionsBefore You BeginOnline CompilersInstalling the Code Bundle
1. Your First C++ Application
IntroductionAdvantages of C++Anatomy of a C++ ApplicationExercise 1: Compiling Our First ApplicationC++ Build PipelineC++ KeywordsKeyword ExamplesPreprocessor DirectivesInclude MacrosConditional CompilationExercise 2: Defining Values with Preprocessor DirectivesBasic I/O StatementsExercise 3: Reading User DetailsFunctionsPassing by Value, Passing by ReferenceWhy Are We Outputting 10? Function OverloadingDefault ParametersExercise 4: FunctionsActivity 1: Writing Your Own C++ ApplicationSummary
2. Control Flow
Introductionif/elseExercise 5: Implementing if/else StatementsTernary OperatorExercise 6: Creating a Simple Menu Program Using an if/else Statementswitch/caseExercise 7: Refactor an if/else Chain into switch/caseLoopswhileExercise 8: Implementing a while Loopdo whileExercise 9: Implementing while and do while Loops with a False ConditionforExercise 10: Implementing a for LoopRange-based for loopExercise 11: Generating Random Numbers Using Loopsbreak/continuebreakcontinueExercise 12: Making a Loop More Efficient Using break and continueActivity 2: Creating a Number-Guessing Game Using Loops and Conditional StatementsSummary
3. Built-In Data Types
IntroductionData TypesType ModifiersBuilt-In TypesReference TableExercise 13: Declaring Data TypesContainersArraysInitializationAccessing ElementsArray MemoryExercise 14: Implementing Containers to Store UsernamesMultidimensional ArraysExercise 15: Using Multidimensional Arrays to Store More DataVectorsAccessing ElementsExercise 16: Looping over a VectorInitializationModifying ElementsExercise 17: Modifying a VectorClasses/StructsClassesStructsAccess ModifiersExercise 18: Using Accessibility Modifiers to Control AccessConstructors/DestructorsExercise 19: Classes/StructStorage LifetimeExercise 20: Storage Lifetime ExampleStaticActivity 3: Sign-Up ApplicationSummary
4. Operators
IntroductionArithmetic OperatorsExercise 21: The Prime Number CheckerRelational OperatorsEqualityComparisonExercise 22: The Time-of-Day CalculatorUnary OperatorsExercise 23: A Pre-Increment/Post-Increment ExampleAssignment OperatorsLogical OperatorsExercise 24: Logical Operators ExampleOperator OverloadingExercise 25: Operator Overloading ExampleBitwise OperatorsActivity 4: Fizz BuzzSummary
5. Pointers and References
IntroductionMemory AddressesPointersExercise 26: PointersExercise 27: Dereferencing nullptrPointers to ArraysExercise 28: Pointers to ArraysPointer ArithmeticExercise 29: Pointer ArithmeticExercise 30: Incrementing PointersPointers to PointersExercise 31: Pointers to PointersReferencesExercise 32: ReferencesExercise 33: Bad ReferencesPointers and References as Function ArgumentsExercise 34: Pointers as Function ArgumentsPointers to Classes or StructsExercise 35: Pointers to Class InstanceReferences as Function ArgumentsExercise 36: References as Function ArgumentsActivity 5: Using Pointers and References to Manipulate an Array of StringsSummary
6. Dynamic Variables
IntroductionDynamic VariablesExercise 37: Creating and Deleting Dynamic Variables of Basic TypesExercise 38: Creating and Deleting Dynamic Class InstancesDynamic ArraysExercise 39: Creating and Deleting Dynamic Arrays of Basic TypesExercise 40: Creating and Deleting Dynamic Arrays of ClassesSeven Dynamic Variable SinsExercise 41: Using a Dynamic Variable before Creating ItExercise 42: Using a Dynamic Variable after Deleting ItExercise 43: Not Deleting a Dynamic VariableExercise 44: Overwriting a Pointer to a Dynamic VariableExercise 45: Deleting a Dynamic Variable TwiceExercise 46: Deleting a Dynamic Array with delete instead of delete[]Exercise 47: Deleting a Dynamic Variable with delete[] instead of deleteDynamic ContainersLinked ListsBinary Search TreesRecursive Data StructuresVisiting Items in a Recursive Data StructureFinding ItemsAdding ItemsDeleting Dynamic ItemsExercise 48: Creating Linked Lists of Class InstancesActivity 6: Creating Binary Search Trees of Class InstancesSummary
7. Ownership and Lifetime of Dynamic Variables
IntroductionThe Lifetime of Dynamic VariablesOwnership of Dynamic VariablesResource Acquisition Is Initialization (RAII)Exercise 49: Lifetime DemonstrationExercise 50: Owned Pointers in Data StructuresExercise 51: Transfer of OwnershipSmart Pointers — Automated Ownership of Dynamic Variablesunique_ptr<>Exercise 52: Working with unique_ptr<>make_unique()Exercise 53: Using make_unique()unique_ptr<> as a Class Member VariableExercise 54: Using unique_ptr<> as a Class Member Variableunique_ptr<> in Function Arguments and Return ValuesExercise 55: Using unique_ptr<> in Function Return ValuesShared Ownership of Dynamic VariablesExercise 56: Using shared_ptr<> make_shared()Exercise 57: Using make_shared()Activity 7: Storing the Words of a Book Using Dynamic VariablesSummary
8. Classes and Structs
IntroductionClasses versus StructsUnionsConstructors and DestructorsConstructorsDefault ConstructorsExercise 58: Defining a Default ConstructorParameterized ConstructorsExercise 59: Defining a Parameterized ConstructorCopy ConstructorsShallow Copy or Deep CopyExercise 60: Defining a Copy ConstructorCopy Assignment OperatorExercise 61: Overloading the Assignment OperatorDestructorsActivity 8: Creating a VideoClip ClassSummary
9. Object-Oriented Principles
IntroductionClasses and OOPS in SOLIDExercise 62: Creating a Class that Prints ValuesEncapsulationExercise 63: Creating a Position Class with Private Member VariablesGetters and SettersExercise 64: Getters and Setters in a Position ClassReturn Value or ReferenceReturn by ValueReturn by ReferenceconstReturning const ReferencesConst FunctionsAbstractionActivity 9: A Basic RPG Combat SystemSummary

10. Advanced Object-Oriented Principles
IntroductionInheritanceExercise 65: InheritanceMultiple InheritanceExercise 66: Multiple Inheritance Access Modifiers and InheritanceExercise 67: Access Modifiers and InheritanceVirtual FunctionsPure Virtual Functions/Abstract ClassesExercise 68: Virtual FunctionsPolymorphismExercise 69: PolymorphismCasting between TypesStatic CastDynamic CastC-Style CastExercise 70: CastingActivity 10: An Encyclopedia ApplicationSummary
11. Templates
IntroductionSyntax Template ClassesExercise 71: Creating Different Types for the Position Objects Multiple Template ParametersTemplate FunctionsExercise 72: Comparing Position Values Using a Template FunctionTemplate SpecializationAdditional Template ConsiderationsForcing Accepted TypesTemplates and Default ConstructorsCreating a Generic QueueWhat Is a Queue?Implementing Constructors and Destructors in the QueueDynamic MemoryAllocatorsResizing and AppendingPushing and PoppingFinalizing and TestingActivity 11: Creating a Generic StackSummary
12. Containers and Iterators
IntroductionContainersA String Is a ContainerString ConstructorsExercise 73: Creating StringsAssigning to StringsOperations on StringsIteratorsFurther ResearchExercise 74: Is It a Palindrome?Vectors-Handy, Resizable ArraysVector ConstructorsVector AssignmentExercise 75: Accessing Elements in a VectorOperations on VectorsSearching VectorsExercise 76: Sorting Vectors with a Custom ComparisonMap/Unordered Map: Our Associative ContainersConstructing Maps and Unordered MapsOperations on Maps and Unordered MapsExercise 77: Map QuizSets/MultisetsConstructorsExercise 78: A Custom Comparator for a SetOperationsExercise 79: Using a Set to Get the Number of Unique Elements in a MultisetQueues/StacksConstructorsOperationsActivity 12: Converting RPG Combat to Use Standard Library ContainersSummary
13. Exception Handling in C++
IntroductionResponding to Unexpected EventsThrowing ExceptionsUncaught ExceptionsExercise 80: Throwing Uncaught ExceptionsCatching ExceptionsExercise 81: try/catch BlocksExercise 82: Exceptions Thrown by C++Unwinding the StackRAII (Resource Acquisition Is Initialization) and Exception HandlingExercise 83: Unwinding the StackActivity 13: Handling ExceptionsSummary
Appendix
1. Your First C++ ApplicationActivity 1: Write Your Own C++ Application2. Control FlowActivity 2: Creating a Number-Guessing Game Using Loops and Conditional Statements3. Built-in Data TypesActivity 3: Sign-Up Application4. OperatorsActivity 4: Fizz Buzz5. Pointers and ReferencesActivity 5: Using Pointers and References to Manipulate an Array of Strings6. Dynamic VariablesActivity 6: Creating Binary Search Trees of Class Instances7. Ownership and Lifetime Of Dynamic VariablesActivity 7: Storing the Words of a Book Using Dynamic Variables8. Classes and StructsActivity 8: Creating a Video Clip Class9. Object-Oriented PrinciplesActivity 9: A Basic RPG Combat System10. Advanced Object-Oriented PrinciplesActivity 10: An Encyclopedia Application11. TemplatesActivity 11: Creating a Generic Stack12. Containers and IteratorsActivity 12: Converting RPG Combat to Use Standard Library Containers13. Exception Handling in C++Activity 13: Handling Exceptions

Overview

The C++ Workshop is your practical guide to mastering C++ programming. Explore foundational concepts such as control flow and data types before advancing to dynamic memory management, object-oriented principles, and efficient standard library usage. With this book, you'll gain the skills and confidence to tackle real-world software engineering tasks.

What this Book will help me do

Develop a strong understanding of core C++ concepts including control flow and data structures.
Write efficient and maintainable C++ code by applying best practices and error-handling techniques.
Master object-oriented programming concepts such as inheritance, polymorphism, and templates.
Apply knowledge of dynamic memory and standard library usage to optimize code performance.
Build practical experience through hands-on exercises and real-world coding challenges.

Author(s)

Dale Green, Kurt Guntheroth, and Shaun Ross Mitchell are accomplished software developers and educators specializing in C++. With extensive professional experience spanning game development, software engineering, and academia, they have a talent for breaking down complex topics into manageable lessons. Their approach emphasizes practicality, preparing readers for real-world implementation of C++ skills.

Who is it for?

This book is tailored for aspiring C++ developers who seek to write clean, efficient, and maintainable code. It's ideal for those with basic programming knowledge in another language, or familiarity with object-oriented programming concepts. Whether you're advancing your career in software engineering or pursuing personal C++ projects, this book will guide you step-by-step.

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

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills