Site Course Catalog  
Course Catalog Public Schedule Services Resources News & Events About Us
Course Catalog
 
Process and
Methods
Java / J2EE
Web Services / XML
WebSphere
WebLogic
.NET
Rational / XDE
Other
100% MONEY BACK WARRANTEE
Featured Courses
Registration FAQ
Client Testimonials
Public Schedule
Promos & Offers
Download Course
Catalog PDF Format

 
 
Advanced C++
Duration: 4 days
Audience Prerequisites
  • Application Developers
  • Programmers
  • System Designers
Description

This course offers a comprehensive coverage of the advanced features of the C++ language.

The course starts with basic OO concepts, and then a quick introduction to the language. The language is presented, not as an extension of C, but as a demonstration of how object-oriented development promotes a new, productive way of thinking.

Other topics covered include Templates, Standard Template Library (STL) and Exceptions. The course also covers some advanced Object-Oriented design techniques in C++ such as Design Heuristics, Design by Contract, Interfaced-based programming, Composition and Delegation Patterns, Memory Management and Smart Pointers, Subtyping, Design for efficiency and Meta programming in C++.

Objectives
InferData's goal is to transfer as much knowledge as possible from the classroom to the workplace. Advanced C++ has been carefully designed to ease a C++ programmer into new and advanced language features and advanced Object-Oriented design concepts in C++ with the use of lots of hands-on exercises. At the end of this course, students should:
  • Apply advanced concepts of OO designs
  • Be able to write and maintain C++ programs
  • Write robust, maintainable, elegant and efficient C++ code
  • Be able to deploy good C++ programming practices
  • Be able to use the advanced features of the C++ programming language
  • Be able to implement advanced Object-Oriented techniques in C++ to realize efficient and flexible applications
  • Leave with skills needed to develop industrial C++ applications
Course Outline
Object-Oriented Technology
  • Perspective
  • Objects in Code
Templates
  • Template Classes Definition
  • Template Classes Implementation
  • Parametrized Classes
  • Templates and Non-Type Parameters
  • Template Guidelines
  • Templates and Plain Functions
  • C++ Template Function
Standard Template Library (STL)
  • STL String
  • STL Components
  • Containers
  • Use of Iterators in STL
  • Use of Vector
  • Initialization of Containers
STL Collections
  • Overriding STL Algorithms
  • Function Objects
  • Library Provided Function Objects
  • Using STL Function Objects and Binders
  • Negators
STL Associative Containers
  • Set
  • Multiset
  • Map
  • Multimaps
Exceptions
  • Object-Oriented Error Handling
  • C++ Exceptions
  • Throwing Exception
  • Exception Classes
  • Exception Class Hierarchies
  • Try / Catch Blocks
  • Catching Exceptions
  • The Rule of Catch Ordering
  • Catching Any Exception
  • Rethrowing an Exception
  • The Throw List
  • Solving Automatic Resource Deallocation
  • Exceptions in the Destructor
  • Design Guidelines
Design by Contract
  • Program Correctness
  • Conditions and Specifications
  • Interface Specification
  • Preconditions and Postconditions
  • Contract Violations
  • Defensive Programming
  • The Eiffel Lesson
  • C++ and Preconditions
  • Postcondition and C++
  • Contracts and Visibility
  • Class Invariants
Interfaces in C++
  • Interfaces and Creation
  • Use of Factory
  • Use of Handles
  • Subsystems And Packages
  • Adapting Interfaces
  • Coupling Through Inheritance
  • Decoupling By Example
Delegation
  • Concept of Delegation
  • Delegation in C++
  • Simple Delegation
  • Static Delegation
  • Superclass Delegation
  • Subclass Delegation
  • Issues With Subclass Delegation in C++
  • Object Delegation
  • Strategy Problem
  • C++ and Strategy
  • Design of Composite
  • Composite and Delegation
  • Other Delegation Patterns
Subtyping
  • Types versus Classes
  • What Is a Type (in Theory)?
  • What is a Class (in Theory)?
  • Subtyping
  • Subclassing
Multiple Inheritance
  • Multiple Inheritance of Interfaces
  • Multiple Inheritance of Implementation
  • Shared Properties
  • Resolving Ambiguity
  • Virtual Inheritance
  • Multi Methods
  • Double Dispatch
  • Use of RTTI
 C++ Reflection
  • Concept of Reflection
  • Lessons from Smalltalk
  • Creation of Objects in Smalltalk
  • Creation of Objects in Smalltalk vs. C++
  • Use of Meta Objects
  • Class Factory
  • Creation of Objects Through Meta Objects
  • Configuration of Meta Objects
  • C++ Support for Meta
  • Dynamic Cast
  • C++ Meta Implementation
  • The Type Information Class
  • Use of type_info
The C++ Language
  • C++ as an Object-Oriented Language
  • Constructors And Destructors
  • I/O Streams
  • Operator Overloading
  • Casting (Static & Dynamic)
  • Cast and Multiple Inheritance
  • Virtual Inheritance
  • Cast with Virtual Multiple Inheritance
  • Const Feature
  • Polymorphic Array
STL Operators
  • accumulate
  • adjacent_find
  • copy
  • count
  • fill
  • find
  • for_each
  • generate
  • includes
  • merge
  • remove
  • replace
  • reverse
  • sort
Other STL Features
  • Container Adaptors
  • Complex Numbers
  • Standard Exception
  • Memory
  • Smart Pointer from the Standard Library
Design Heuristics
  • Object-Oriented Design Guidelines
  • Reflecting Client's View
  • Polling
  • Express Interfaces Through Objects<
  • Value Objects
  • Class Invariants
  • Abstract Base Classes
  • Classes and Interfaces
  • Design Interfaces Between Base and Derived Classes
  • Classes Cohesiveness
  • Interface Bloat
  • Encapsulation Leakage
Decoupling
  • What is Coupling?
  • Kinds of Coupling
  • Identity Coupling
  • Identity Coupling: Object Lifetimes
  • Change of Identity
  • Type Coupling
  • Implementation Coupling
  • Interfaces and Implementations
Causality
  • Event Registration
  • Observer and Observables
  • C-Style Callbacks
  • C-Style Subject
  • Object-Oriented Function Pointers
  • Object-Oriented Callback
  • Type Safety and Callbacks
  • Templated Callback
  • Function Callback
  • Use of Callbacks
Memory Management
  • Basic Guidelines
  • Match Constructors with Destructors
  • Singleton
  • Initialization of Global Objects
  • Smart Pointers
  • Overloading New and Delete
  • Operator new
  • Operator delete
  • Changing New Handler
C++ Inheritance
  • Rules and Guidelines
  • Inheritance of Baseclass Methods
  • Change of Methods
  • Contracts and Inheritance
  • Contracts and Subtyping
  • Variations of Method Arguments
  • Rules for Method Arguments
  • Rules for Changing Return Types
  • Cancellations of Methods
Efficiency
  • Performance Analysis
  • Ground Rules
  • Locality of Reference
  • Use of Inline Functions
  • Data Locality
  • Lazy Evaluation
  • Copy on Write
  • Lazy Fetching
  • Eager Evaluation
  • Caching
  • Performance and Responsiveness
  • Utilization of Threads
  • Asynchronous Protocols
  • Futures
 
11149 Research Blvd., Suite 350, Austin, TX 78759 | 512.306.8225 Site Map | © 2005 InferData, Ltd.