book

Practical C++

Name: Practical C++
Author: Rob McGregor
ISBN: 9780789721440

by Rob McGregor

August 1999

Beginner to intermediate

912 pages

15h 44m

English

Que

Read now

Unlock full access

Practical C++
About the Author
Acknowledgments
Tell Us What You Think!
Introduction
Who Should Read This BookWhat Experience Do You Need?The History and Evolution of C++How This Book Is OrganizedPart I: C++ BasicsPart II: Beyond the BasicsPart III: Object-Oriented ProgrammingPart IV: Using the Standard C++ LibraryFormatting ConventionsSource Code on the Web: The Practical C++ Web SiteHow to Contact the Author
I. C++ Basics
1. Getting Started with C++
Creating a C++ ProgramWriting Source CodeCompiling and Linking Source FilesBuilding Executable ProgramsCompilingLinkingTesting Your CodeCase SensitivityIntroducing FunctionsDeclaring FunctionsMaking a Sandwich: A Study in Problem SolvingCreating and Using Code BlocksIntroducing the main() FunctionUsing C-Style and C++-Style CommentsC-Style CommentsC++-Style CommentsImportant C++ KeywordsUsing Basic Input/Output StreamsRealizing That Input/Output Streams Are C++ ObjectsUsing the #include DirectiveThe Standard Output StreamThe Standard Input StreamThe Standard Error Stream
2. Exploring C++ Data Types, Variables, and Constants
Understanding C++ Data TypesExploring the Fundamental Data TypesThe Integer TypeThe Character TypeThe Boolean TypeFloating-Point and Double-Precision TypesIntroducing Derived Data TypesArraysPointers and ReferencesStructures, Unions, and ClassesIntroducing the Standard StringUsing VariablesDeclaring and Defining VariablesInitializing VariablesUsing Named ConstantsDeclaring and Initializing Named ConstantsTypes of ConstantsInteger ConstantsCharacter ConstantsFloating-Point ConstantsString LiteralsUsing Named Constants in Source CodeResolving the Scope of Variables and ConstantsUnderstanding Declarations and DefinitionsDeclaration Specifiers and DeclaratorsSpecifying LinkageSpecifying Storage ClassCasting Data TypesCasting ImplicitlyCasting Explicitly
3. Examining Expressions and Statements
OverviewUnderstanding ExpressionsUsing Operators and OperandsPrimary ExpressionsPostfix Operators and Postfix ExpressionsUnary Operator ExpressionsBinary Operator ExpressionsPointer-to-Member Operator ExpressionsConditional Operator ExpressionsExplicit Cast ExpressionsUsing StatementsExpression StatementsCompound StatementsSelection StatementsIteration StatementsDeclaration StatementsJump StatementsLabel Statements
4. Using Conditional Expressions and Selection Statements
Using Boolean Conditions and ExpressionsUnderstanding Boolean ExpressionsUsing the Logical OperatorsLogical ANDLogical ORLogical NOTEvaluating Boolean Conditions with Truth TablesA Truth Table for the AND OperatorA Truth Table for the OR OperatorA Truth Table for the NOT OperatorCreating More Complex Truth TablesUsing the Conditional OperatorUnderstanding Operator PrecedenceUsing Selection StatementsUsing the if StatementThe else ClauseNesting if StatementsUsing the switch StatementUsing Enumerations

5. Building Iteration Loops
Why Use Loops?Phases of Loop ExecutionExamining Iteration StatementsUsing the for StatementUsing a for Loop for Temperature ConversionCreating Infinite Loops Using the for StatementUsing the while StatementUsing a while Loop for Temperature ConversionCreating Infinite Loops Using the while StatementUsing the do StatementUsing a do Loop for Temperature ConversionCreating Infinite Loops Using the do StatementDesigning LoopsDesigning the Flow of Interactive Program ControlUsing break and continue for Greater Loop ControlUsing Nested LoopsPutting It All Together
6. Using Arrays
Why Use Arrays?Understanding One-Dimensional ArraysDefining an ArrayAccessing Array ElementsAccessing Array Elements Through IterationInitializing One-Dimensional Arrays During DeclarationUsing Parallel ArraysUnderstanding Two-Dimensional ArraysProcessing Two-Dimensional ArraysWorking with ColumnsWorking with RowsImplementing a Multiplication TableMulti-Dimensional Arrays
7. Creating and Using Functions
Why Use Functions?Various Types of FunctionsVoid FunctionsFunctions That Return a ValueInline FunctionsComponents of a FunctionFunction Return Types and ValuesFunction ParametersDefault ParametersCreating Your Own FunctionsDeclaring a FunctionDefining a FunctionUsing Local VariablesUsing Command-Line ArgumentsGetting the Number of ArgumentsGetting and Using the ArgumentsA Command-Line Argument-Processing ProgramAnalyzing the Program CodeUsing Variable-Argument ListsGetting Modular with FunctionsSpecifying Function Linkage
II. Beyond the Basics
8. Overloading Functions
Why Use Function Overloading?Types of Function OverloadingOverloading by Parameter TypeChanging the Data Types of Function ParametersChanging the Number of Function ParametersChanging the Number of Function Parameters and Their Data TypesChanging a Function’s Return Data TypeOverloading Functions by OperationExamining the Internals of Function OverloadingMangling Function Names for Type-Safe LinkageFunction Calls and the StackStepping Through the Stack of Function Calls
9. Using Structures and Unions
Creating New Data Types with StructuresAdding Data Types as Structure MembersCreating Arrays of StructuresStructures as Data MembersPresenting a Payroll Processing ProgramExamining the Payroll Processing ProgramAdding Functions as MembersUsing Unions for Efficient StorageAccessing Union MembersDefining Structures as Union MembersDefining Unions as Structure Members
10. Using Pointers and References
OverviewUnderstanding PointersWhy Use Pointers?Memory AddressingDeclaring a PointerDereferencing a PointerGetting Pointers to StructuresUsing Pointer-to-Member NotationUsing Pointers as Function ParametersUsing Arrays as PointersPassing Arrays to FunctionsPassing Array ElementsPassing an Entire ArrayUsing Pointer ArithmeticUnderstanding ReferencesDeclaring and Initializing a ReferenceUsing References as Function ParametersUsing References as Function Return Values
11. Allocating Memory in C++
Allocating Static MemoryAllocating Dynamic MemoryThe StackThe Free Store (The Heap)Using the new and delete OperatorsUsing the new OperatorUsing the delete OperatorAllocating ArraysCreating Dynamic Arrays of StructuresDealing with Allocation ErrorsDetecting Memory Allocation FailuresUsing the set_new_handler() FunctionCreating Your Own new and delete Operators
12. Understanding the Preprocessor
Introducing the PreprocessorUnderstanding Preprocessing PhasesUnderstanding Preprocessor DirectivesIncluding FilesDefining and Undefining SymbolsCompiling ConditionallyGetting Platform IndependentSingle-File InclusionExcluding Debug CodeOutputting ErrorsUnderstanding PragmasExploring MacrosDefining MacrosExpanding MacrosUsing Preprocessor OperatorsUsing the # OperatorUsing the ## OperatorConsidering Internationalization IssuesDigraph SequencesTrigraph SequencesKeyword SequencesExamining Predefined Macros
13. Creating and Using Function Pointers
How Can a Function Have a Pointer?Some Reasons for Declaring Pointers to FunctionsDeclaring and Using Function PointersDeclaring a New Data TypeUsing a Function Pointer TypeCreating Arrays of Function PointersUsing Pointers to Overloaded FunctionsUsing Pointers to Member Functions
14. Overloading Operators
Why Overload Operators?An Operator Is a Function CallOverloading an OperatorSome Examples of Operator OverloadingOverloading the Assignment OperatorOverloading Relational OperatorsOverloading the Function Call Operator
15. Bulletproofing Programs with Assertions and Exceptions
Devising Error Handling StrategiesHandling Runtime ErrorsHandling Programming ErrorsUsing AssertionsUnderstanding the assert() MacroSome Guidelines for Using AssertionsDemonstrating AssertionsHandling ExceptionsThe try BlockThe catch Exception HandlerThe throw StatementUsing Exception HandlingCatching Unexpected ExceptionsCleaning Up Allocated Resources
16. Exploring Namespaces
What Is a Namespace?Declaring a NamespaceUnnamed NamespacesGetting Explicit Access to NamespacesThe using DeclarationThe using DirectiveUsing Namespace AliasesUsing Composite NamespacesThe Global NamespaceThe Standard Namespace
17. Analyzing the Mathematics of Memory
OverviewExamining Bases of Numeration SystemsReviewing the Decimal Numeration System (Base 10)Analyzing the Binary Numeration System (Base 2)Converting Binary to DecimalConverting Decimal to BinaryAnalyzing the Octal Numeration System (Base 8)Converting Octal to DecimalConverting Decimal to OctalA Base Conversion Program: CONVERTAnalyzing the CONVERT ProgramAnalyzing the Hexadecimal Numeration System (Base 16)Converting Hexadecimal to DecimalConverting Decimal to HexadecimalConverting Hexadecimal to BinaryConverting Binary to Hexadecimal
18. Manipulating Bits
Working with BitsUnderstanding Bit NumberingUnderstanding Bit FieldsDeclaring a Bit FieldUsing a Bit FieldUsing Bit OperatorsThe Bitwise AND OperatorThe Bitwise Inclusive OR OperatorThe Bitwise Exclusive OR Operator (XOR)The One’s Complement (NOT) OperatorManipulating Bits in Signed and Unsigned NumbersExploring Bit-ShiftingUsing the Left-Shift OperatorUsing the Right-Shift Operator
19. Compiling, Linking, and Debugging
Exploring the CompilerUnderstanding How Compilers WorkGenerated Object CodeResolving Compiler ErrorsExploring the LinkerResolving Linker ErrorsAutomating Builds Using Make FilesFinding and Fixing Buggy CodeAdding Debug CodeUsing the Preprocessor for DebuggingStrategies for Testing and Debugging
III. Object-Oriented Programming
20. Introducing Object-Oriented Programming
Fundamentals of Object-Oriented ProgrammingMoving from Procedural Programming to OOPBlack Boxes and BugsThe Object AdvantageConceptualizing ObjectsInheritanceIntroducing Polymorphism and Virtual MethodsObject-Oriented Software StrategiesVirtual Functions, Inherited Data Members, and Code BloatUnderstanding Objects and Classes in C++Examining the Benefits of Code ReuseStop Reinventing the WheelUsing Code Libraries
21. Understanding C++ Classes
Creating C++ ClassesThinking About Class DesignEncapsulating DataDeclaring ClassesSpecifying Access ControlSpecifying Public AccessSpecifying Private AccessSpecifying Protected AccessDefining Data MembersDefining Non-Static Data MembersDefining Static Data MembersUsing Constructors and DestructorsConstructor FunctionsThe Destructor FunctionUnderstanding the this PointerCreating Copy ConstructorsCreating Member OperatorsDefining Member FunctionsDefining Static Member FunctionsDefining Non-Static Member FunctionsUsing Pointer-to-Member Operator ExpressionsDesigning and Implementing a Rectangle ClassDesigning the CRect InterfaceImplementing the CRect Class
22. Implementing Class Inheritance
Understanding Base and Derived ClassesCreating Class HierarchiesDesigning Constructors and Destructors in a HierarchyOverriding Base Class FunctionsProviding Scope Resolution for Base and Derived ClassesCalling Base Class FunctionsImplementing a Class HierarchyUsing Friend Functions and ClassesUsing Friend FunctionsUsing Friend ClassesCreating Class LibrariesCreating a Binary Library of Your ClassesUsing the Library
23. Understanding Polymorphism
What Is Polymorphism?Getting VirtualUnderstanding Virtual FunctionsCreating Abstract Base ClassesDefining Pure Virtual FunctionsUnderstanding Virtual TablesUsing Pointers to Classes in a HierarchyPolymorphing with PointersCreating a Polymorphic Class HierarchyResolving Class SlicingUsing Virtual Destructors
24. Implementing Dynamic Storage in C++
Container ClassesCreating Dynamic ArraysCreating a Dynamic Array ClassAdding an ItemInserting an ItemFinding an ItemDeleting an ItemClearing All Array ElementsCreating an Array Assignment OperatorThe Dynamic Array Class InterfaceImplementing the Dynamic Array ClassCreating a Driver ProgramCreating Linked ListsCreating a Linked List ClassImplementing a Node ClassAdding a NodeTraversing the ListFinding an ItemInserting a NodeDeleting All Nodes from the ListDeleting a NodeThe Linked List Class InterfaceImplementing the Linked List ClassCreating a Driver Program
25. Designing and Developing Object-Oriented Programs
Problem-Solving TechniquesExploring the Development ProcessAnalyzing System RequirementsUndertaking a ProjectIdentifying Classes Needed to Build the SystemDesigning InterfacesUsing Modular Source FilesCreating Interface (Header) FilesCreating Implementation FilesDevising Class MethodsInterfaces in ActionAccessibility IssuesTesting and Integrating ModulesAvoiding Multiple DefinitionsTesting FunctionalityIntegrating ModulesReusing Code
26. Using Templates
Conceptualizing TemplatesAvoiding Redundant CodeCreating Function TemplatesUsing Multiple Generic Class TypesCreating a Basic Class TemplateDesigning a Template SkeletonFleshing Out the TemplateCreating a More Complex Class TemplateConverting Existing Classes into Class TemplatesCreating a Generic Linked List ClassImplementing a Generic Node ClassProblems with Separating the Class Interface and ImplementationAltering the List Class Interface and ImplementationAdding a NodeTraversing the ListFinding an ItemInserting a NodeDeleting All Nodes from the ListDeleting a NodeCreating a Driver Program
27. Using Dynamic Casting and Runtime Type Identification
Getting and Using Runtime Type InformationOld-School Type Casting (C Style)New-School Type Casting (C++ Style)Using the dynamic_cast OperatorUsing the const_cast OperatorUsing the reinterpret_cast OperatorUsing the static_cast Operator
IV. Using the Standard C++ Library
28. Introducing the Standard C++ Library
An Overview of the Standard C++ LibraryUsing the Standard NamespaceIdentifying Standard C++ Header FilesIntroducing the Standard Template LibraryUsing the Standard C LibraryIdentifying the Components of the Standard C++ LibraryDiagnosticsInput/OutputLanguage SupportLocalizationNumericsStringsUtilitiesIdentifying STL ComponentsAlgorithmsContainersIteratorsFunction ObjectsAdaptorsAllocators
29. Using Iterators and Containers
Understanding IteratorsCreating an Iterator ClassTypes of Standard IteratorsExploring Iterator OperationsIterator ClassesUsing Input IteratorsUsing Output IteratorsUsing Forward IteratorsUsing Bidirectional IteratorsUsing Random-Access IteratorsUnderstanding ContainersSequence ContainersVectorsDequesListsAssociative ContainersSets and MultisetsMaps and Multimaps
30. Using Strings
Characters and Standard StringsCreating Character StringsIdentifying International ConcernsSingle-Byte Character SetsMultibyte Character SetsCreating Other Types of StringsDefining Character TraitsInvestigating the basic_string ClassUsing String OperatorsString IteratorsString ConstructionUsing String FunctionsAssignment MethodsAppending and Inserting MethodsInformational MethodsStandard C-Style String Conversion MethodsString Comparison MethodsString Find and Replace MethodsSubstring Manipulation Methods
31. Working with Numerics
Identifying Numeric HeadersUsing Standard Math FunctionsGenerating Random NumbersWorking with Complex NumbersIntroducing valarraysExploring Numeric AlgorithmsThe accumulate AlgorithmThe inner_product AlgorithmThe partial_sum AlgorithmThe adjacent_difference Algorithm
32. Working with Files and Streams
Working with StreamsIdentifying Stream TypesIntroducing the ios_base ClassFormat FlagsI/O State FlagsOpen Mode FlagsSeek Direction FlagsEvent FlagsIntroducing the basic_ios ClassIntroducing the basic_istream ClassIntroducing the basic_ostream ClassIntroducing the basic_iostream ClassIntroducing the basic_fstream ClassUsing Stream ManipulatorsCreating Formatted Stream DataUsing File StreamsWriting and Reading Text FilesWorking with Multiple FilesWriting and Reading a Binary File
33. Examining Algorithms
Generic AlgorithmsExploring the Nonmodifying Sequence AlgorithmsCounting AlgorithmsThe count AlgorithmThe count_if AlgorithmFind AlgorithmsThe adjacent_find AlgorithmThe find AlgorithmThe find_first_of AlgorithmThe find_if AlgorithmThe for_each AlgorithmSearch AlgorithmsThe find_end AlgorithmThe search AlgorithmThe search_n AlgorithmSequence Comparison AlgorithmsThe equal AlgorithmThe mismatch AlgorithmExploring the Modifying Sequence AlgorithmsCopy AlgorithmsThe copy AlgorithmThe copy_backward AlgorithmFill and Generate AlgorithmsThe fill AlgorithmThe fill_n AlgorithmThe generate AlgorithmThe generate_n AlgorithmReplace AlgorithmsThe replace AlgorithmThe replace_copy AlgorithmThe replace_copy_if AlgorithmThe replace_if AlgorithmRemove AlgorithmsThe remove AlgorithmThe remove_copy AlgorithmThe remove_copy_if AlgorithmThe remove_if AlgorithmReverse and Rotate AlgorithmsThe random_shuffle AlgorithmThe reverse AlgorithmThe reverse_copy AlgorithmThe rotate AlgorithmThe rotate_copy AlgorithmSwap AlgorithmsThe iter_swap AlgorithmThe swap AlgorithmThe swap_ranges AlgorithmThe transform AlgorithmUnique AlgorithmsThe unique AlgorithmThe unique_copy AlgorithmExploring the Sorted Sequence AlgorithmsBinary Search AlgorithmsThe binary_search AlgorithmThe equal_range AlgorithmThe lower_bound AlgorithmThe upper_bound AlgorithmMerge AlgorithmsThe inplace_merge AlgorithmThe merge AlgorithmPartition AlgorithmsThe partition AlgorithmThe stable_partition AlgorithmSet Operation AlgorithmsThe includes AlgorithmThe set_difference AlgorithmThe set_intersection AlgorithmThe set_symmetric_difference AlgorithmThe set_union AlgorithmSorting AlgorithmsThe nth_element AlgorithmThe partial_sort AlgorithmThe partial_sort_copy AlgorithmThe sort AlgorithmThe stable_sort AlgorithmExploring the Heap Operation AlgorithmsThe make_heap AlgorithmThe pop_heap AlgorithmThe push_heap AlgorithmThe sort_heap AlgorithmExploring the Comparison AlgorithmsThe lexicographical_compare AlgorithmThe max AlgorithmThe max_element AlgorithmThe min AlgorithmThe min_element AlgorithmExploring the Permutation AlgorithmsThe next_permutation AlgorithmThe prev_permutation Algorithm
Standard C++ Library Header Files
Inside Front Cover
A Quick Reference to Key TopicsArraysAssertions, Exceptions, and NamespacesClassesCompiling, Linking, and DebuggingData TypesExpressions and StatementsFunctionsMemory ManagementObject-Oriented Design and DevelopmentPointers and ReferencesThe Standard C++ LibraryTemplates
Inside Back Cover
Important C++ Keywords

Content preview from Practical C++

Chapter 22. Implementing Class Inheritance

Understand base and derived classes
See how to create class hierarchies
Discover how to override base class functions
Learn about friend classes and functions
See how to create binary class libraries

</feature>

Understanding Base and Derived Classes

The object-oriented programming paradigm is based on the concept of object hierarchies that are created through inheritance. In this system, a simple base class acts as a foundation on which you can build more complex classes. The resulting classes can then act as the foundation for even more complex classes, and so on. A class that’s built from an existing class, to extend its capabilities in some way, is called a derived class.

Inheritance

In C++ programming, ...

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

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Practical C++

by Rob McGregor

Chapter 22. Implementing Class Inheritance