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 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