C++
ADVANCE YOUR CAREER
C++ Courses
C++ Programming
Close
C++ Programming
Course Number:
N/A
Develop the ability to design and write programs in the C++ language, emphasizing object-oriented approaches to designing solutions.
Audience:
This course is intended for C programmers responsible for the development of advanced applications or systems programs in C++.
Course Duration:
5 days
Prerequisites:
Participants are recommended to have experience in C Programming before taking this class.
Course Objectives:
Course Outline:
- Course Introduction
- Course Objectives
- Course Overview
- Suggested References
- Classes
- Creating a Data Structure
- Methods
- Object Scope
- C++ Input and Output
- Namespaces
- Data Abstraction
- Enforcing
- Data Encapsulation
- File Organization
- Classes in C++
- Objects
- This Pointer Constructors and Destructors
- Debug Output
- The Default Constructor
- When are Constructors Called?
- The Destructor
- The Copy Constructor
- Other Constructors
- Why Did It Work Before?
- Composition The Report Class
- Code Reuse
- Initialization Lists
- Inheritance
- Inheritance
- Bug report
- Protected Access Modifier
- Access and Inheritance
- Constructors and Inheritance
- Initialization Lists Revisited
- Multiple Inheritance
- Virtual
- Functions
- Inheritance and Assignment
- Inside Report’s Assignment Operator
- Using Pointers
- A Quick Look at Basics
- Class Assignment and Pointers
- Static Binding
- Dynamic Binding
- Polymorphism
- The show_rep() Function
- Using the show_rep() Function
- Designing Member Function Inheritance
- Pure Virtual Functions
- Bug fix and Its Relationship with Bug report
- Bug fix: Association with Bug report
- Using Bug fix with show_rep()
- Adding Bug fix to the Hierarchy
- Coding for the Document Class
- Reexamining the Document Class
- Pure Virtual Functions
- Updated: Designing Member Function
- Inheritance
- References and Constants
- References
- Displaying References
- Changing References
- Pass by Reference
- Returning by Reference
- Constant Variables
- Constant References
- Constant Methods
- C++ Programming
- ITCourseware, LLC 2
- C++ Programming Rev 2.1.2
- New and Delete
- New and delete
- Array Allocation
- The Report Class
- Compiler Version of the Copy
- Constructor
- Guidelines for Copy Constructors
- The Report Constructors and new
- The Report Destructor and delete
- Virtual Destructors
- Casting in C++
- Casting: A Review
- New Casting Syntax
- Creating a String Class
- The String Class
- The Conversion Constructor
- Expanding Our Casting Options
- Casting Operator oUsing the Casting Operator
- Class Methods and Data
- Class Data
- Class Methods
- Using the New Data
- More on Class Methods
- Overloaded Functions
- Function Overloading
- Using Overloaded Functions
- Rules for Overloading
- Overloading Based on Const.
- Default Arguments
- Invoking Functions with Default
- Arguments
- Overloaded Operators
- The Basics of Overloading
- Overloading operator+
- Coping with Commutatively
- Non-Commutative Operators
- Friends and Their Problems
- The Assignment Operator
- Overloading the << Operator
- Using Date with cout
- Exception Handling
- Why Exception Handling?
- Try / catch / throw
- Exception Classes
- Standard Exception Hierarchy
- Multiple Catch Blocks
- Catching Everything
- Unhandled Exceptions
- Exception in Constructors and
- Destructors
- Designing for Exceptions
- Standard Template Library
- Class Template Concepts
- Standard Template Library (STL)
- Overview
- Containers oIterators
- Iterator Syntax
- Non-Mutating Sequential Algorithms
- Mutating Sequential Algorithms
- Sorting Algorithms
- Numeric Algorithms
- Auto_ptr Class
- String Class
- STL Containers
- Container Classes
- Container Class Algorithms
- Vector Class
- Additional vector Class Methods
- Deque Class
- List Class
- Set and Multi-Set Classes
- Map and Multi-Map Classes
- Appendix A
- Reference Sheets
- Constants, References, and Pointers
- Input/output
- This Pointer
- The Complete Report/Document
- Hierarchy
- Appendix B
- Templates
- Scenario
- Designing an Array Class
- Code for FloatArray
- Code for IntArray
- Templates
- Template Syntax
- Using Templates
- Using Classes with Templates
- Additional Template Features
- Standard Template Library
- Appendix C
- Sample Problems
- Banking System
- Library Card Catalog
C++ Programming for C Programmers
Close
C++ Programming for C Programmers
Course Number:
N/A
This course is a comprehensive hands-on introduction to object-oriented programming in C++ for C programmers. Emphasis is placed on the features of C++ that support effective modeling of the problem domain and reuse of code.
The course consists of two modules. In the first module, object-oriented concepts are introduced in addition a step-by-step instruction regarding the C++ class construct. Participants wills also study function and operator overloading, the use of references, the scope and access control mechanisms and inheritance.
The second module presents intermediate topics. The ANSI C++ Standard Library is covered, including namespaces, the new header files and basic string class. Templates are explored, as well as I/O streams and practical issues of C ++ programming, such as reliability, testing, efficiency and interfacing.
This course introduces newer features of C++ such as exceptions, runtime type information (RTTI and the new C++ cast syntax. It is designed so it may be taught in any environment with an ANSI C++ compiler and extensive programming examples and exercises are provided.
Audience:
This course is intended for C programmers who are moving to object oriented programming in C++.
Course Duration:
5 days
Prerequisites:
Participants are recommended to have a good working knowledge of C programming before attending this class.
Course Objectives:
Course Outline:
- Concepts of Object-Oriented Programming
- Object
- State and Behavior
- Abstraction
- Encapsulation
- Class and Instantiation
- Abstract Data Types
- Methods
- Invoking Methods
- Messages
- Class Inheritance
- Polymorphism
- Classes in C++
- Data Encapsulation in C
- The C++ Class
- Structures and Class in C++
- Implementation of a C++ Class
- This Pointer
- Code Organization
- Scope Resolution Operator
- Abstract Data Types
- Test Programs for C++ Classes
- Functions in C++
- Function Prototypes in C++
- Strong Type Checking
- Conversion of Parameters
- Inline Functions
- Inline Functions in Header Files
- Default Arguments
- Function Overloading
- Argument Matching
- Argument Matching through Promotion
- Match through Type Conversion
- Call by Value
- Constructors and Destructors
- The Problem of Initialization
- Constructors and Initialization
- Constructor in Stack Class
- Object Creation and Destruction
- Destructors
- Multiple Constructors
- String Class Implementation
- Hidden Constructors
- C++ Programming for C Programmers
- Using a Default Argument
- Memory Management in C++
- Why is Memory Management Important in C++?
- Choices for an Object’s Memory
- Typical Memory Layout
- Free Store Allocation
- New Operator
- Memory Allocation Errors
- New vs. Malloc
- Delete Operator
- Destructor (Review)
- Hiding Memory Management
- String Class Specification (Version 2)
- String Class Implementation
- String Class Bug
- References and Argument Passing in
- C++
- Variables
- Argument Passing
- Call-by-Value
- Reference Declarations
- Call-by-Reference
- Copy Constructor
- Default Copy Constructor
- Bug in String Class
- Specification of String Class
- Implementation of String Class
- Test Program
- Output of Test Program
- Review of Constant Types
- Constants and Arguments
- Chains of Functions Calls
- Const Objects and Member Functions
- Operator Overloading, Initialization and Assignment Operator Overloading
- Operator Functions
- Semantics of return
- Returning a Temporary Object
- Returning a Reference oInitialization vs. Assignment
- Semantics of Assignment oAssignment
- Assignment Bug
- Overloading =
- Review of this Pointer
- Type Conversions
- Conversion by Construction
- Overloading Cast Operator
- Test Program
- Scope and Access Control
- Scoping in C++
- Block and Function Scope
- File and Global Scope
- Class Scope
- Constant Types and Scope
- Enumeration Types
- Enumeration Types and Class Scope
- :: for Global Data
- Static Class Members
- Initialization of Static Member
- Static Function Class Members
- Access Control
- Friend Functions
- Invoking Member and Friend Functions
- Implementing a Friend Function
- Efficiency and Friend Functions
- Introduction to Inheritance
- Inheritance Concept
- Inheritance in C++
- Employee Test Program
- Protected Members
- Best Class Initializer List
- Composition
- Member Initializer List
- Order of Initialization
- Inheritance vs. Composition
- Polymorphism and Virtual Functions
- A Case for Polymorphism
- Dynamic Binding
- Pointer Conversion in Inheritance
- Polymorphism Using Dynamic Binding
- Virtual Function Specification
- Invoking Virtual Functions
- Vtable
- Virtual Destructors
- Abstract Class Using Pure Virtual
- Function
- Employee as an Abstract Class
- Heterogeneous Collections
- ANSI C++ Library
- ANSI C++ Library
- Hello ANSI C++
- C++ Programming for C Programmers
- Namespaces
- ANSI C++ String Class
- Templates
- Templates
- General Purpose Functions
- Macros oFunction Templates
- Template Parameters
- Template Parameter Conversion
- Generic Programming
- General Purpose Classes
- Class Templates
- Array Class Implementation (array.h)
- Using the Array Template
- Template Parameters
- Class Template Instantiation
- Non Type Parameter Conversion
- Standard Template Library
- STL Components
- STL Elements of a Simple Program
- Simple STL Program
- Map Container
- Input/ Output in C++
- Input/ Output in C++
- Built-in Stream Objects
- Output Operator <<
- Input Operator >>
- Character Input
- String Input
- Formatted I/O
- Streams Hierarchy (Simplified)
- File I/O
- File Opening
- Integer File Copy
- Character File Copy
- Overloading Stream Operators
- Implementing Overloaded Stream
- Operators
- Practical Aspects of C++
- Programming
- Interfacing C++ to Other Languages
- Calling C from C++
- _cplusplus Macro
- Calling C++ from C
- Interface Module for Stack Class
- Namespace Collisions
- ANSI Namespace
- Reliability Philosophies of Languages
- Prototypes and Type Checking
- Constant Types
- Access Control in C++
- Reviews and Inspections
- Inspections and C++
- Testing Strategies for C++
- Performance Considerations
- Class Libraries
- Exception Handling
- Exception Handling
- Try and catch
- Exception Flow of Control
- Context and Stack Unwinding
- Handling Exception in Best Context
- Benefits of Exception Handling
- Unhandled Exceptions
- Clean Up
- Multiple Catch Handlers
- Runtime Type Information
- Runtime Type and Polymorphism
- type_info Class
- typeid Operator
- Compiler Options
- Safe Pointer Conversions
- Dynamic Cast
- New C++ Style Casts
- Static Cast
- Reinterpret Cast
- Const Cast
C++ Programming for Non-C Programmers
Close
C++ Programming for Non-C Programmers
Course Number:
N/A
This course is a comprehensive, hands-on introduction to object-oriented programming in C++ for non-C programmers. Emphasis is placed on the features of C++ that support effective modeling of the problem domain and reuse of code.
The course consists of two modules. The first module introduces the core C features of C++ with simplified input/output through IOStreams. The module begins with simple hands-on programming using C++ to do input, computation and output. The C++ data types are covered, and simple if tests and loops are covered. C++ program structure is introduced as well as pointers, addressing and arrays.
In the second module, object-oriented concepts are introduced. Participants will study the C++ class construct, C++ memory management, function and operator overloading, the use of references and inheritance. The scope and access control mechanisms of C++ are described.
Extensive programming examples and exercises are provided. The course is current to ANSI standard C++ and is designed so that it can be taught in any environment with an ANSI C++ compiler.
Audience:
This course is intended for non-C programmers who are moving to object oriented programming in C++.
Course Duration:
5 days
Prerequisites:
Participants are recommended to have knowledge of a programming language before attending this class.
Course Objectives:
Course Outline:
- First C++ Programs
- Hello, World
- Compiling and Running
- C++ Program Components
- Another C++ Program (Preview)
- I/O in C++
- Variables
- Expressions
- Assignment
- Using C++ as a Calculator
- Input in C++
- Echo Program
- Data Types and Operators
- Data Types
- Strong Typing
- Typing in C++
- Conversions in C++
- Typing in Visual Basic
- Primitive C++ Data Types
- Signed and Unsigned
- Twos Complement
- C++ Integer Type Ranges
- IntegerRange.cpp
- Integer Constants
- Variables in C++
- Const Variables
- Preprocessor Macros
- Identifiers
- Floating Point Numbers
- Floating Point Data Types
- Calculations
- Integer Operations
- Increment and Decrement
- Precedence of Integer Operations
- Floating Point Operations
- op=
- Mixed Data Types
- Automatic Conversion
- Cast
- Math Library
- Logical and Bit Operations
- Bool Variables
- Bool Operations and Truth Tables
- Relational Operators oIf Tests
- Flow Chart
- C++ Programming for Non-C Programmers
- A Pitfall
- Bitwise Operators
- Bitwise Operator Truth Tables
- Short Circuit Evaluation
- Shifting
- Masking
- Loops and Structured Programming
- Loops
- While Loops
- Infinite Loops
- Flowcharting a While Loop
- Indenting and Curly Braces
- Accumulating a Total
- Total Using a Sentinel
- Counted Loops
- Total Using a Counter
- For Loops
- Total Using a For Loop (Up)
- Total Using a For Loop (Down)
- Comparing For and While Loops
- Variable Scope
- Loops and If Tests Together
- Nested If Statements
- Review of Statements
- Compound Statements
- Structured Programming
- Object-Oriented Programming
- Functions and Program Structure
- Basics of Functions
- Function Prototypes and Type Checking
- Returning Value
- Argument Passing
- Pass-by-Reference
- Alternative to Pass-by-Reference
- External Variables
- Block Structure
- Scope Rules
- Header Files
- Preprocessor Directives
- Conditional Compilation
- Recursion
- Pointers and Arrays
- Pointers and Addresses
- Pointers and Function Arguments
- Pointers and Arrays
- Address Arithmetic
- Dynamic Memory Management
- Using malloc and free
- Array of Pointers
- Strings
- String Functions
- Array of Strings
- Command Ling Arguments
- Pointers to Functions
- Structures and Unions
- Fundamentals of Structures
- Structure Declaration
- Structures and Functions
- Typedef
- Arrays of Structures
- Array of Structures Initialization
- Unions
- Concepts of Object-Oriented
- Programming
- Object
- State and Behavior
- Abstraction
- Encapsulation
- Class and Instantiation
- Abstract Data Types
- Methods
- Invoking Methods
- Messages
- Class Inheritance
- Polymorphism
- Classes in C++
- Data Encapsulation in C
- The C++ Class
- Structures and Class in C++
- Implementation of a C++ Class
- This Pointer
- Code Organization
- Scope Resolution Operator
- Abstract Data Types
- Test Programs for C++ Classes
- Functions in C++
- Function Prototypes in C++
- Strong Type Checking
- Conversion of Parameters
- Inline Functions
- Inline Functions in Header Files
- Default Arguments
- Function Overloading
- Argument Matching
- C++ Programming for Non-C Programmers
- Argument Matching through Promotion
- Match through Type Conversion
- Call by Value
- Constructors and Destructors
- The Problem of Initialization
- Constructors and Initialization
- Constructor in Stack Class
- Object Creation and Destruction
- Destructors
- Multiple Constructors
- String Class Implementation
- Hidden Constructors
- Using a Default Argument
- Memory Management in C++
- Why is Memory Management Important in C++?
- Choices for an Object’s Memory
- Typical Memory Layout
- Free Store Allocation
- New Operator
- Memory Allocation Errors
- New vs. malloc
- Delete Operator
- Destructor (Review)
- Hiding Memory Management
- String Class Specification (Version 2)
- String Class Implementation
- String Class Bug
- References and Argument Passing in
- C++
- Variables
- Argument Passing
- Call-by-Value
- Reference Declarations
- Call-by-Reference
- Copy Constructor
- Default Copy Constructor
- Bug in String Class oSpecification of String Class
- Implementation of String Class
- Test Program
- Output of Test Program
- Review of Constant Types
- Constants and Arguments
- Chains of Functions Calls
- Const Objects and Member Functions
- Operator Overloading, Initialization and Assignment
- Operator Overloading
- Operator Functions
- Semantics of return
- Returning a Temporary Object
- Returning a Reference
- Initialization vs. Assignment
- Semantics of Assignment
- Assignment
- Assignment Bug
- Overloading =
- Review of this Pointer
- Type Conversions
- Conversion by Construction
- Overloading Cast Operator
- Test Program
- Scope and Access Control
- Scoping in C++
- Block and Function Scope
- File and Global Scope
- Class Scope
- Constant Types and Scope
- Enumeration Types
- Enumeration Types and Class Scope
- :: for Global Data
- Static Class Members
- Initialization of Static Member
- Static Function Class Members
- Access Control
- Friend Functions
- Invoking Member and Friend Functions
- Implementing a Friend Function
- Efficiency and Friend Functions
- Introduction to Inheritance
- Inheritance Concept
- in C++
- Employee Test Program
- Protected Members
- Best Class Initializer List
- Composition
- Member Initializer List
- Order of Initialization
- Inheritance vs. Composition
- Polymorphism and Virtual Functions
- A Case for Polymorphism
- Dynamic Binding
C++ Programming for Non-C Programmers Supplement
Close
C++ Programming for Non-C Programmers Supplement
Course Number:
N/A
This course provides a solid foundation in C++ for those without any C programming experience. This course will cover the features of the C++ language and emphasizes key object -oriented programming concepts.
Audience:
This course is intended for programmers moving to object-oriented programming using C++.
Course Duration:
3 Days
Prerequisites:
Participants are recommended to have professional programming experience before attending this class.
Course Objectives:
Course Outline:
- Course Introduction
- Course Objectives
- Course Overview
- Getting Started
- The First Program (hello.cpp)
- Compile Steps
- How to Compile and Run a Program
- Data Types and Variables
- Fundamental Data Types
- Data Type Values and Sizes
- Variable Declarations
- Variable Names
- Constants
- Character Constants
- String Constants
- Operators and Expressions
- What Are Expressions?
- Arithmetic Operators
- Relational Operators
- Assignment Operator
- Expressions Have Resulting Values
- True and False
- Logical Operators
- Increment and Decrement Operators (++ and–)
- Operate-Assign’ Operators (+=, *=, …)
- Conditional Expression
- Operator Precedence
- Precedence and Order of Evaluation
- Evaluation of Logical Operators
- Type Conversions
- The Cast Operator
- Control Flow
- Statements
- if- else if () – else if ()
- switch()
- while()
- do – while()
- for()
- The for() loop – Diagram
- The Break Statement
- The Continue Statement
- Functions
- What Is a Function?
- Why Use Functions?
- Anatomy of A Function
- Arguments Passed by Value
- When to Use the Return Statement
- Returning Non-Integer Values
- Functions in Multiple Source Files
- The Concept of Variable Scope
- Automatic Variables
- Global (External) Variables
- Static Variables
- External Static Variables
- Pointers and Arrays
- What is a Pointer?
- Pointer Operators
- Why Use Pointers?
- Arrays
- The and Operator
- Pointers and Arrays
- Passing Arrays to Functions
- Initializing Arrays
- Strings and Character Pointers
- What is char s[7] ???
- Arrays of Pointers
- Command Line Arguments
- Structures
- Comparison of Structures and Arrays
- Structure Definitions
- Structure Declarations
- Arrays of Structures
C++ Standard Template Library
Close
C++ Standard Template Library
Course Number:
N/A
This course provides the student with the knowledge to improve C++ programs using generic programming, templates, and the Standard Template Library.
Audience:
This course is intended for C++ programmers who need to take advantage of the Standard Template Library.
Course Duration:
3 Days
Prerequisites:
Participants are recommended to have several years of programming in C++ before attending this class.
Course Objectives:
Course Outline:
- Basic Concepts
- Origin and History of the Standard
- Template Library
- Why Use the STL?
- What is the Standard Template Library?
- Foundation C++ Concepts
- Generic Programming with Templates
- Why Templates?
- Function Templates
- Class Templates
- Template Specialization
- Default Template Parameters
- Non-Type Template Parameters
- Template Parameters
- Other Template Related Topics
- Using Templates
- Components of the STL
- Sequential Containers
- Containers
- Sequential Containers
- The Vector Container
- The Deque Container
- The List Container
- The String Class
- The Bitset Container
- The Valarray Container
- Iterators
- What Is an Iterator?
- Iterators in the STL
- Random Access Iterators
- Bidirectional Iterators
- Forward Iterators
- Input Iterators
- Output Iterators
- Associative Containers
- What is an Associative Container?
- The Pair Container
- The Set Container
- The Multiset Container
- The Map Container
- The Multimap Container
- The Hashed Associative
- Container
- Adapted Iterators
- What Are Iterator Adaptors?
- The Inserter Iterator Adaptor
- The Reverse Iterator Adaptor
- The Stream Iterator Adaptor
- Adapted Containers
- What Are Container Adaptors?
- The Stack Container Adaptor
- The Queue Container Adaptor
- The priority_que Container Adaptor
- Functors
- What is a Functor?
- Classifying Functors
- Functions Pointers Review
- Arithmetic Functors
- Relational Functors
- Logical Functors
- Function Adaptors
- What Are Function Adaptors?
- The Binder Function Adaptors
- The Negator Function Adaptors
- Member Function Adaptors
- Pointers to Functions
- User Defined Functors
- Non-Mutating Algorithms
- Algorithms
- Non-Mutating Algorithms
- Searching
Advanced C++ Programming
Close
Advanced C++ Programming
Course Number:
N/A
This comprehensive course consists of three modules. A preliminary module reviews topics, including inheritance, the ANSI C++ Standard Library, templates, I/O streams, and practical issues such as reliability, testing, efficiency and interfacing to C. This material can be customized or removed depending on the level of class knowledge.
The second module covers more advanced topics. Issues of inheritance and polymorphism are covered, as well as principles of effective class design, exception handling and runtime type information (RTTI). Participants will explore multiple inheritance, including the complications that are introduced by this powerful feature, and advanced applications of C++ concepts, including smart pointers and reference counting.
The third module introduces the Standard Template Library (STL). The main components of data structures, algorithms and iterators will all be studies. Illustrations are provided of a number of important containers – such as vectors, stacks, queues, lists and sets – and extensive programming examples and exercises are provided. A number of progressively developed case studies are used to illustrate object oriented programming techniques and to give the student practical experience in putting together features of C++ learned in the course.
Audience:
This course is intended for experienced C++ programmers who wish to deepen their understanding of the language and learn advanced techniques.
Course Duration:
5 days
Prerequisites:
Participants are recommended to have substantial C++ programming experience before attending this class.
Course Objectives:
Course Outline:
- Inheritance and Polymorphism
- Inheritance Concept oInheritance in C++
- Protected Members
- Base Class Initializer List
- Composition
- Member Initialization List
- Order of Initialization
- Inheritance vs. Composition
- Summary – Inheritance
- A Case for Polymorphism
- Dynamic Binding
- Pointer Conversion in Inheritance
- Polymorphism Using Dynamic Binding
- Virtual Functi oon Specification
- Invoking Virtual Functions
- VTable
- Virtual Destructors
- Abstract Class Using Pure Virtual
- Function
- Employee as an Abstract Class
- Heterogeneous Collections
- Summary – Polymorphism
- ANSI C++ Library
- ANSI C++ Library
- Hello ANSI C++
- Namespaces
- ANSI C++ String Class
- Templates
- Templates
- General Purpose Functions
- Macros oFunction Templates
- Template Parameters
- Template Parameter Conversion
- Function Template Problem
- Generic Programming
- General Purpose Classes
- Class Templates
- Array Class Implementation (array.h)
- Using the Array Template
- Template Parameters
- Advanced C++ Programming
- Class Template Instantiation
- Non Type Parameter Conversion
- Standard Template Library
- STL Components
- Generic Programming
- STL Elements of a Simple Program
- Simple STL Program
- Map Container
- Input/Output in C++
- Input/Output in C++
- Built-in Stream Objects
- Output Operator << oInput Operator >>
- Character Input
- String Input
- Formatted I/O
- Streams Hierarchy (Simplified)
- File I/O
- File Opening
- Integer File Copy
- Character File Copy
- Overloading Stream Operators
- Implementing Overloaded Stream
- Operators
- Practical Aspects of C++
- Programming
- Interfacing C++ to Other Languages
- Calling C from C++
- _cplusplus Macro
- Calling C++ from C
- Interface Module for Stack Class
- Namespace Collisions
- ANSI Namespace
- Reliability Philosophies of Languages
- Prototypes and Type Checking
- Constant Types
- Access Control in C++
- Reviews and Inspections
- Inspections and C++
- Testing Strategies for C++
- Performance Considerations
- Class Libraries
- Advanced Polymorphism and Inheritance
- Inheritance
- Good Class Design
- String Class
- Public Inheritance
- Public Inheritance Problems
- Inheritance and Semantics
- Private Inheritance
- Composition
- Composition vs. Private Inheritance
- Templates vs. Inheritance
- Protected Inheritance
- Implementation Encapsulation
- Interface Inheritance
- Exception Handling
- Exception Handling
- Try and catch
- Exception Flow of Control
- Context and Stack Unwinding
- Handling Exceptions in best Context
- Benefits of Exception Handling
- Unhandled Exceptions
- Clean Up
- Multiple Catch Handlers
- Runtime Type Information
- Runtime Type and Polymorphism
- Type_info Class
- Typeid Operator
- Compiler Options
- Safe Pointer Conversions
- Dynamic Cast
- New C++ Style Casts
- Static Cast
- Reinterpret Cast
- Const Cast
- Inheritance Hierarchies and Multiple
- Inheritance
- Class Hierarchy in Smalltalk
- Smalltalk Class Hierarchy (Simplified)
- Collection Classers
- Multiple Inheritance Solution
- Basic Derivation
- Ambiguities in Multiple Inheritance
- Resolving Ambiguity
- Duplicate Subobjects
- Virtual Base Classes
- Applications of C++ Concepts
- Orthodox Canonical Form (Review)
- Object Validation
- String Class
- Smart Strings
- Reference Counting
