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
Share on facebook
Share on twitter
Share on linkedin
Share on email

Related Posts

About Us
Ntier company logo

IT Training, Agile Ways of Working and High Impact Talent Development Strategies

Let Us Come to You!

Classes recently delivered in: Atlanta, Boston, Chicago, Columbus, Dallas, Detroit, Indianapolis, Jerusalem, London, Milan, New York, Palo Alto, Phoenix, Pittsburgh, Portland, Raleigh, San Antonio, San Diego, San Francisco, San Jose, Seattle, Springfield, Mass., St. Louis, Tampa and more!