Shopping Cart :Check Out

Effective C++ Programming Outline


Effective C++ Programming is a 5 Days Program.Attendees perform hands on embedded programming, on PC during course practicals. Approximately 50% of the course is given over to practical work

Course Contents

The C++ Language Basics Operator Overloading Runtime Type Identification & Casting Operators
A quick contrast on features of C++ & C The operator function RTTI
A simple C++ program Operators that cannot be overloaded Runtime Polymorphism & RTTI
A C++ build Phase Overloading unary operators typeid & type_info
Exploring GNU Tool chains for debugging skills Overloading Binary operators Application illustration using Base class pointer
Cascading of I/O operators Using member functions & friend functions – when to use what Passing pointers to functions
Type compatibility Interpreting the operator function call Function receiving references
Scope resolution operator Function overloading the operator function Factory methods & RTTI
Pointers and arrays The assignment operator Template classes & RTTI
Const qualifiers with pointers Implicit overloading mechanism The Casting operators
Storage classes Explicit overloading mechanism dynamic_cast
Memory Allocation Returning objects & assignment operator const_cast
new Overloading >> & << operators static_cast
delete Cascading operators & returning reference reinterpret_cast
Functions in C++ Overloading new & delete operators
Strict prototyping Special operator overloads
Inline functions operator == , operator [ ], operator ( ),
Default arguments operator –>, operator comma (,)
Return by reference
Function overloading
Pass by value, address and reference
Constructors and Destructors Classes and Objects Static members and objects on the heap
Definition & declaration Class declaration & object mechanism Static members of a class
Characteristics of constructors Access specifiers Static data members
Overloaded constructors Separating interface from implementation Static member functions
Copy constructor Inline member functions A discussion on static members
Destructors Nested member functions Objects on the heap
Dynamic constructors Memory allocation for objects The this pointe
Array of objects Objects & references
Use of constructors
Constructors and Destructors Friend and classes Inheritance
Managing the heap Object communication The inheritance mechanism
Constructors & Destructors – internal behaviour Friend functions Types of inheritance
Passing objects Friend classes Single level, multi level, multiple, hierarchical, hybrid
Objects & references Const objects and const member functions Inheritance – is it allocation or accessibility
Copy constructor Object composition & destruction mechanism The protected access specifier
Overloading copy constructor Boundary classes & object interfaces Inheritance in private, protected & public mode
Objects & references Constructors & destructors in a derived class
Copy constructor Multiple inheritance
Overloading copy constructor Virtual Base class
Returning objects Invoking base class constructors
Returning object references Why a constructor is not inherited
Passing & returning pointers to objects Is-a & Has-a relationship
Nested classes & Containership
Runtime Polymorphism, Virtual Functions & Dynamic Binding Exception Handling Templates
Pointers & Classes Exception handling fundamentals Generic functions & Data abstraction
Pointers to Class Members try, catch & throw Function templates
Method overriding Using multiple catch Explicitly specializing a function template
Base class pointers & derived class objects The ‘catch all' exception handler Overloading Function Template
Virtual functions Nested try blocks Using standard parameters
Virtual functions & base class pointers Rethrowing an exception & overruling a function's return value A Generic Sort algorithm
Virtual functions & base class reference Restricting Exceptions – the throw list Generic Classes (Class template)
Dynamic Binding v/s Early Handling derived class exceptions Using more than one generic type
Binding Setting the terminate and unexpected handlers Using non-type arguments & default arguments
Pure virtual functions Application of Exception handling Explicit Specializations
Virtual destructors Applications of templates - a Stack template
Abstract classes & applications Template template parameter
Design of STL
Techniques of Usage

Note: This is a generic content & can be customized for individual needs!

Training Programs