book

Deciphering Object-Oriented Programming with C++ [WARNING: NOT FOR USE IN OTHER MATERIAL/SEE CONTRACT]

Name: Deciphering Object-Oriented Programming with C++ [WARNING: NOT FOR USE IN OTHER MATERIAL/SEE CONTRACT]
Author: Dorothy R. Kirk
ISBN: 9781804613900

by Dorothy R. Kirk

September 2022

Intermediate to advanced

594 pages

15h 11m

English

Packt Publishing

Read now

Unlock full access

Deciphering Object-Oriented Programming with C++
ContributorsAbout the authorAbout the reviewers
Preface
Who this book is for?What this book coversTo get the most out of this bookDownload the example code filesCode in ActionDownload the color imagesConventions usedGet in touchShare Your Thoughts
Part 1: C++ Building Block Essentials
Chapter 1: Understanding Basic C++ Assumptions
Technical requirementsReviewing basic C++ language syntaxComment stylesVariable declarations and standard data typesVariables and array basicsRecapping basic I/OThe iostream libraryBasic iostream manipulatorsRevisiting control structures, statements, and loopingControl structures – if, else if, and elseLooping constructs – while, do while, and for loopsReviewing C++ operatorsRevisiting function basicsReviewing user defined type basicsstructtypedef and “using” alias declarationclassenum and strongly-typed enumRecapping namespace basicsSummaryQuestions
Chapter 2: Adding Language Necessities
Technical requirementsUsing the const and constexpr qualifiersconst and constexpr variablesconst qualification with functionsWorking with function prototypesDefining function prototypesNaming arguments in function prototypesAdding default values to function prototypesPrototyping with different default values in different scopesUnderstanding function overloadingLearning the basics of function overloadingEliminating excessive overloading with standard type conversionAmbiguities arising from function overloading and type conversionSummaryQuestions
Chapter 3: Indirect Addressing – Pointers
Technical requirementsUnderstanding pointer basics and memory allocationRevisiting pointer basicsUsing the address-of and dereference operatorsUsing operators new() and delete() Creating and using pointers to user defined typesAllocating and deallocating arrays at runtimeDynamically allocating single dimension arraysDynamically allocating 2-D arrays – an array of pointersDynamically allocating 2-D arrays – pointers to pointersDynamically allocating N-D arrays – pointers to pointers to pointersUsing pointers with functionsPassing pointers as arguments to functionsUsing pointers as return values from functionsUsing the const qualifier with pointersUsing pointers to constant objectsUsing constant pointers to objectsUsing constant pointers to constant objectsUsing pointers to constant objects as function arguments and as return types from functionsUsing pointers to objects of unspecified typesCreating void pointersLooking ahead to smart pointers for safetySummaryQuestions
Chapter 4: Indirect Addressing – References
Technical requirementsUnderstanding reference basicsDeclaring, initializing, and accessing referencesReferencing existing objects of user defined types Using references with functionsPassing references as arguments to functionsUsing references as return values from functionsUsing the const qualifier with referencesUsing references to constant objectsUsing pointers to constant objects as function arguments and as return types from functionsRealizing underlying implementation and restrictionsUnderstanding when we must use pointers instead of referencesSummaryQuestions
Part 2: Implementing Object-Oriented Concepts in C++
Chapter 5: Exploring Classes in Detail
Technical requirementsIntroducing object-oriented terminology and conceptsUnderstanding object-oriented terminologyUnderstanding object-oriented conceptsUnderstanding class and member function basicsExamining member function internals; the “this” pointerUsing access labels and access regionsUnderstanding constructorsApplying constructor basics and overloading constructorsConstructors and in-class initializersCreating copy constructorsCreating conversion constructorsUnderstanding destructorsApplying destructor basics and proper usageApplying qualifiers to data members and member functionsAdding inline functions for potential efficiencyAdding const data members and the member initialization listUsing const member functionsUtilizing static data members and static member functionsSummaryQuestions
Chapter 6: Implementing Hierarchies with Single Inheritance
Technical requirementsExpanding object-oriented concepts and terminologyDeciphering generalization and specializationUnderstanding single inheritance basicsDefining base and derived classes and accessing inherited membersExamining inherited access regionsSpecifying a class as finalUnderstanding inherited constructors and destructors Implicit constructor and destructor invocationsUsage of member initialization list to select a base class constructorPutting all the pieces togetherImplementation inheritance – changing the purpose of inheritanceModifying access labels in the base class list by using protected or private base classes Creating a base class to illustrate implementation inheritanceUsing a private base class to implement one class in terms of anotherUsing a protected base class to implement one class in terms of anotherSummaryQuestions

Chapter 7: Utilizing Dynamic Binding through Polymorphism
Technical requirementsUnderstanding the OO concept of polymorphismImplementing polymorphism with virtual functionsDefining virtual functions and overriding base class methodsGeneralizing derived class objectsUtilizing virtual destructorsPutting all the pieces togetherConsidering function hidingUnderstanding dynamic bindingComprehending runtime binding of methods to operationsInterpreting the v-table in detailSummaryQuestions
Chapter 8: Mastering Abstract Classes
Technical requirementsUnderstanding the OO concept of an abstract classImplementing abstract classes with pure virtual functionsCreating interfaces Generalizing derived class objects as abstract types Putting all the pieces together SummaryQuestions
Chapter 9: Exploring Multiple Inheritance
Technical requirementsUnderstanding multiple inheritance mechanicsExamining reasonable uses for multiple inheritanceSupporting Is-A and mix-in relationshipsSupporting Has-A relationshipsCreating a diamond-shaped hierarchyUtilizing virtual base classes to eliminate duplicationConsidering discriminators and alternate designsSummaryQuestions
Chapter 10: Implementing Association, Aggregation, and Composition
Technical requirementsUnderstanding aggregation and compositionDefining and implementing compositionDefining and implementing a generalized aggregationUnderstanding associationImplementing associationUtilizing backlink maintenance and reference countingSummaryQuestions
Part 3: Expanding Your C++ Programming Repertoire
Chapter 11: Handling Exceptions
Technical requirementsUnderstanding exception handlingUtilizing exception handling with try, throw, and catchExploring exception handling mechanics with typical variationsUtilizing exception hierarchiesUsing standard exception objectsCreating customized exception classesCreating hierarchies of user defined exception typesSummaryQuestions
Chapter 12: Friends and Operator Overloading
Technical requirementsUnderstanding friend classes and friend functionsUsing friend functions and friend classesMaking access safer when using friendsDeciphering operator overloading essentialsImplementing operator functions and knowing when friends might be necessarySummaryQuestions
Chapter 13: Working with Templates
Technical requirementsExploring template basics to genericize codeExamining the motivation for templatesUnderstanding template functions and classesCreating and using template functionsCreating and using template classesExamining a full program exampleMaking templates more flexible and extensible Adding operator overloading to further genericize template codeSummaryQuestions
Chapter 14: Understanding STL Basics
Technical requirementsSurveying the contents and purpose of the STLUnderstanding how to use essential STL containersUsing STL listUsing STL iteratorUsing STL vectorUsing STL dequeUsing STL stackUsing STL queueUsing STL priority queueExamining STL mapExamining STL map using a functorCustomizing STL containersSummaryQuestions
Chapter 15: Testing Classes and Components
Technical requirementsContemplating OO testingUnderstanding the canonical class formDefault constructorCopy constructorOverloaded assignment operatorVirtual destructorMove copy constructorMove assignment operatorBringing the components of canonical class form togetherEnsuring a class is robustCreating drivers to test classesTesting related classesTesting classes related through inheritance, association, or aggregationTesting exception handling mechanismsEmbedding exception handling in constructors to create robust classesSummaryQuestions
Part 4: Design Patterns and Idioms in C++
Chapter 16: Using the Observer Pattern
Technical requirementsUtilizing design patternsUnderstanding the Observer patternImplementing the Observer patternCreating an Observer, Subject, and domain-specific derived classesSummaryQuestions
Chapter 17: Applying the Factory Pattern
Technical requirementsUnderstanding the Factory Method patternImplementing the Factory Method patternIncluding the Factory Method in the Product classCreating an Object Factory class to encapsulate the Factory Method SummaryQuestions
Chapter 18: Applying the Adapter Pattern
Technical requirementsUnderstanding the Adapter patternImplementing the Adapter patternUsing an Adapter to provide a necessary interface to an existing classUsing an Adapter as a wrapperSummaryQuestions
Chapter 19: Using the Singleton Pattern
Technical requirementsUnderstanding the Singleton patternImplementing the Singleton patternUsing a simple implementationAn alternate simple implementationUsing a more robust paired-class implementationUsing a registry to allow many classes to utilize SingletonSummaryQuestions
Chapter 20: Removing Implementation Details Using the pImpl Pattern
Technical requirementsUnderstanding the pImpl patternImplementing the pImpl patternOrganizing file and class contents to apply the pattern basicsImproving the pattern with a unique pointerUnderstanding pImpl pattern trade-offsSummaryQuestions
Part 5: Considerations for Safer Programming in C++
Chapter 21: Making C++ Safer
Technical requirementsRevisiting smart pointersUsing smart pointers – uniqueUsing smart pointers – sharedUsing smart pointers – weakExploring a complementary idea – RAIIEmbracing additional C++ features promoting safetyRevisiting range for loopsUsing auto for type safetyPreferring STL for simple containersApplying const as neededConsidering thread safetyMultithreaded programming overviewMultithreaded programming scenariosUtilizing core programming guidelinesExamining guideline essentialsAdopting a programming guidelineUnderstanding resources for programming safely in C++Summary
Assessments
Chapter 1, Understanding Basic C++ AssumptionsChapter 2, Adding Language NecessitiesChapter 3, Indirect Addressing: PointersChapter 4, Indirect Addressing: ReferencesChapter 5, Exploring Classes in DetailChapter 6, Implementing Hierarchies with Single InheritanceChapter 7, Utilizing Dynamic Binding through PolymorphismChapter 8, Mastering Abstract ClassesChapter 9, Exploring Multiple InheritanceChapter 10, Implementing Association, Aggregation, and CompositionChapter 11, Handling ExceptionsChapter 12, Friends and Operator OverloadingChapter 13, Working with TemplatesChapter 14, Understanding STL BasicsChapter 15, Testing Classes and ComponentsChapter 16, Using the Observer PatternChapter 17, Applying the Factory PatternChapter 18, Applying the Adapter PatternChapter 19, Using the Singleton PatternChapter 20, Removing Implementation Details Using the pImpl Pattern
Index
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Overview

Deciphering Object-Oriented Programming with C++ is the ultimate guide to achieving mastery in OO design and development using the C++ language. With a focus on practical guidance, this book takes you through implementing modern programming techniques, creating maintainable software, and efficiently utilizing design patterns to solve complex coding challenges.

What this Book will help me do

Master the core object-oriented programming features available in C++.
Write cleaner and more maintainable code using design principles and patterns.
Learn advanced C++ techniques such as templates and operator overloading.
Efficiently debug and test your object-oriented C++ programs.
Gain expertise in utilizing the STL library and creating extensible systems.

Author(s)

Dorothy R. Kirk, the author of Deciphering Object-Oriented Programming with C++, brings extensive experience as a software engineer and educator. With years of hands-on development and teaching experience, Dorothy provides clear and accessible explanations that cater to developers of all levels.

Who is it for?

This book is ideal for programmers with basic C++ knowledge looking to deepen their understanding of object-oriented programming processes. If you aim to write more effective, maintainable, and robust C++ code while mastering the use of object-oriented principles, this book is tailored for you.

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

Practical C++ Design: From Programming to Architecture

Publisher Resources

ISBN: 9781804613900

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills