Home

Courseware

Course
Listing

Instruction

Philosophy

Clients

Publications

Résumé

C++ for Non-C Programmers

Summary:

This course is an introduction to modern software engineering concepts of construction using object-oriented programming and design. In this programming paradigm, programs are organized into two distinct parts: the application itself (the client) and the classes used by the application (the servers).

The organization of this course reflects the organization of object-oriented programs.

  • Client Synthesis. Participants will learn how to build applications using a general-purpose server class library instead of developing applications from scratch each time.
  • Server Synthesis. The participants will learn how to develop new classes from scratch and from existing classes.
    • There is an extensive number of case studies and hands-on laboratory exercises that typically require students to extend of complete a case study program.

    Who Should Take This Class? This course is designed for system analysts, software developers and engineers. Knowledge of a modern structured-programming language such as C or Pascal is helpful but not necessary.

    Course Outline:

    Overview of Object-Oriented Programming:

    The Modular Programming Model
    The Client-Server Model
    Encapsulation and Data Abstraction
    User Defined Types and Classes
    Composition, Parameterized Types and Inheritance
    Polymorphism and Dynamic Binding
    Client Synthesis

    Data Abstraction
    Data Abstraction: A Basis for Program Modularization
    Object: Instances of Types
    Separating Interface and Implementation
    Features for Data Abstraction and User Defined Types
    Sample Class Library
    Reusable Software Components
    The Class Library: String, Linked List, Ordered Collection, Array, Set and Map
    The Class Library's Syntactic and Semantic Interface
    Examples: Using the Class Library
    Enforcement of the Interface     Server Synthesis

    Implementing New Classes
    Classes for User Defined Types
    Data Members and Member Functions
    Data Visibility
    Object Constructors and Destructors
    Simulating Features of Built-in Types
    Changing Implementations without Changing Interfaces
    Examples: Implementations of General-Purpose Classes
     Key Concepts Creating User-Defined Types by Composition
    Interface between a class and its member objects
    Techniques for creating a new class with member classes
    Member object initialization
    Copy constructors
    Implementation of general-purpose classes that use composition


    Creating User-Defined Parameterized Types
    Interface between parameterized type and its type arguments
    Notation for parameterized types
    Simulating parameterized types
    Implementation of general-purpose classesthat use parameterized types


    Creating User-Defined Types with Inheritance
    Creating new classes with inheritance
    Type hiererarchy and class hierarchy
    Information hiding
    Default object copying language mechanisms
    Implementation of some of the general-purpose classes that use inheritance

    Extending Existing Types with Dynamic Binding

    Example of dynamic binding
    Status versus dynamic binding
    Dynamic binding and inheritance
    Virtual functions and the dynamic binding.
    Introduction and Overview of C++ Two Approaches to Programming
    Procedural Programming
    Object-Oriented Programming
    Goals of the C++ Language
    Compatibility
    Optimization
    Portability
    Promotion: A Discipline for Reuse
    Encapsulation and Data Hiding
    Restaurant Programming
    Semantically Consistent Polymorphism
    Semantically Disparate Polymorphism     Data Abstraction Reusable Software
    Complexity
    Software Architecture
    Problem domain -> Software Domain
    Encapsulating human expertise
    Portability, Maintainability, Testability
    Organizing Software
    Package Data and Operations     C++ As Better C Program Structure
    Statements
    Expressions
    Memory Management
    Value Semantics     Class User Programming in C++ Types and user-defined types
    User-defined types and classes
    The concept of reusable software components
    Demonstrate reusable software components
    Examples that use user-defined types     Class Synthesis for Class Users Part I Introduction Value Semantics
    Middle Ground
    Class Synthesis Using Built-In Data Types
    Parameterization
    C++ Support for OOAD (Object-Oriented Analysis and Design)
    Multiplicity
    Aggregation and class synthesis
    Inheritance, mix-ins and class synthesis
    Collaboration
    Delegation     Class Synthesis for Class Users Part II Containers Arrays
    Multiply dimensioned arrays
    Strings
    Subscripting
    Lvalues and Rvalues
    Returning References
    Constant arguments
    Defining I/O for Containers
    Members, Friends & C-Style Function
    Hughes Class Library (HCL) Class Synthesis Value Semantics with Pointers Default constructors
    Conversion constructors
    Copy constructors
    Assignment operators
    Destructors
    Friend, Member & C-Style Functions
    Memory Allocation
    Static (Global)
    Automatic (Local)
    Dynamic
    Class String     Advanced Object-Oriented Programming Using C++ A Review of Value Semantics Converting an Implementation of C Style Array to a C++ Styled Array Class
    Classes for User Defined Types
    Data Members and Member Functions
    Data Visibility
    Object Constructors and Destructors
    Implementing Value Semantics with the Five Special Member Functions
    Overloading Operators for User Defined Classes
    Defining I/O for User Defined Classes
    Avoiding name Collisions with Nested Classes
    Simulating Features of Built-In Types
    Changing Implementations without Changing Interfaces
    Examples: Implementations of General-Purpose Classes     Creating User-Defined Types by Composition Interface between a class and its member objects
    Techniques for creating a new class with member classes
    Member object initialization
    Copy Constructors
    Implementation of general-purpose classes that use composition     Creating User-Defined Parameterized Types Template Classes vs. Pure Abstract Classes
    Template Oddities
    Template Functions
    Implementing Multi-dimensional Arrays
    Passing Objects to Parameterized Types
    Interface between the parameterized type and its type arguments
    Notation for parameterized types
    Template Class Specialization
    Comparing Different Implementations of the Template Feature
    Perils and Merits of Nesting Classes
    Implementation of general-purpose classes that use parameterized types
    Using Inheritance with Parameterized Types     Creating User-Defined Types with Inheritance Creating new classes with inheritance
    Type hierarchy and class hierarchy
    Information hiding
    Default object copying language mechanisms
    Implementation of some of the general-purpose classes that use inheritance     Extending Existing Types with Dynamic Binding Example of dynamic binding
    Static versus dynamic binding
    Virtual functions and the dynamic binding     Special Issues Static Member Functions
    User Defined Conversion
    The Prposed Exception Handling Features
    Simulating Exceptions
    Problems with Operator Overloading
    Implementing Dynamic Arrays
    Reference Count Objects




    Please contact Sieg to arrange for rapid, custom courseware development, or to inquire about his availability to deliver training to your organization: Phone 303-494-5509, Email siegfried@heintze.com.


    Siegfried Heintze
    (303) 494-5509
    www.heintze.com
    siegfried@heintze.com



    Home ||| Courseware ||| Course Listing ||| Instruction
    Philosophy ||| Clients ||| Publications ||| Résumé