Introduction to C++: Acquainting yourself with Objects
(CPPINT, 5 days)


This SETC Certified course gives participants everything they need to get started with object oriented programming using C++. Beginning with a brief overview of basic C++ syntax, the course quickly moves to the concepts of encapsulation and class programming using the most flexible language in the modern world. Concepts such as static data, virtual functions, inheritance and polymorphism are discussed from a practical point of view. Upon completion, participants will have mastered the fundamentals of object oriented programming using C++.

Dates and Pricing

Jan 8 to Jan 12, 2018$3,350/person Feb 5 to Feb 9, 2018$3,350/person Mar 5 to Mar 9, 2018$3,350/person


The place of C++ in the extended family of programming languages
Binary compatible, source compatible and interpreted code
Visual Basic, C++, Java and scripting languages
C++ versus C
Strengths and weaknesses of C++
The origins of C++
The code development process: The need for planning
Best Practices of Software Engineering
Characteristics of a good software solution
How good software is built
Iterative development
Requirements management
Use of component-based architectures
Ongoing verification of software quality
Control of software changes
The Software Engineering Process
The Rational Unified Process
The Inception Phase
The Elaboration Phase
The Construction Phase
The Transition Phase
The RUP: Dynamic Structure
Symptoms and Root Causes of Software Development Problems
Use Cases in the Overall Process
Business Process Modeling
Use Cases in the Software Development Process
Use Cases and Requirements
Management of Requirements and Use Cases
Writing Use Cases
Graphical Notation
Use Case Formats
Use Case Sections
The Supplementary Specification
Design with UML
Functional versus Non-Functional Requirements
Moving from Analysis to Design
Modeling the Database
UML Business Activity Diagrams
UML: Design Class Diagrams
UML: Sequence Diagrams
UML: Statechart Diagrams
Dealing with Large Systems
Implementing a Change Management Process
Essential preparatory topics
Memory architecture: The heap and the stack
Variables: declaration and instantiation
Variables: the assignment operator
Casting and conversion: Old style C versus specific casting operators
Variables: using objects and constructors
Declaring constants
Using const effectively (What about #define)
The World of Pointers and Memory Management
The architecture of pointers
Declaring pointers on the heap and on the stack
The new and delete operators
Using const with pointers
Using null and pointers
Operators and pointers
Using iostream functions
The signature of a function
Defining the scope of a function
Using friend functions
Passing parameters by reference or by pointer?
Passing parameters by value
Returning values from a function call
Inline functions
Object oriented concepts and Classes
What is an object oriented programming?
Defining effective and reusable
Object Oriented Design: A general approach using UML
The object in C++: the class
Defining member variables
Encapsulation: The need for private member variables
Creating properties: Defining inspector functions
Creating a simple object
Creating methods
Defining the scope of a member: private, public and protected
The special case of the constructor
Defining constructors
Defining destructors
Pointers and classes
Using static members and functions
Reference counting
Building a simple class
Constructors, Destructors and Basic Operators
Defining constructors
Using member initialization lists
The default constructor
The copy constructor
The canonical form
The destructor
Overloading the assignment operator
Overloading basic arithmetic operators (operator+, operator-, etc…)
Overloading the postfix and prefix operators
Defining conversion operators
Conflicting conversion issues
Building a more complicated class using forwarding and reference counting
Working with multiple objects and multiple files
Object oriented design
Inheritance and polymorphism
Defining the inheritance list
Public, private and protected inheritance
Friendship and inheritance
Defining polymorphism
Using virtual functions
Working with base class pointers
Building a multiple class example
Defining abstract base classes
Using Templates
What is a template
Template performance issues
Building a function template
Data Structures: Arrays, Lists, and Maps
Class templates
Building a linked list from scratch
About STL and other template libraries