C++ Component Development Using the Active Template Library 3.0 Functional Specification

This course will teach programmers how to build component-based solutions using the Component Object Model (COM), the Active Template Library 3.0 (ATL), and Microsoft® Visual C++®.

Be the first to review this product

SKU: 1304

Subscription Lengths *

$95.00

Qty:

DEMO: This is a sample video of this course.

Course Length: 08 Hours 21 Minutes 15 Seconds
The paid version of this course contains videos of following topics:

At Course Completion

At the end of the course, students will be able to:

    Use COM to address component-based software development issues.
    Build clients of COM objects.
    Build COM object servers.
    Create ActiveX controls.
    Use Visual C++ extensions to create clients of COM objects.
    Build COM objects that reuse existing COM objects.
    Add events to COM objects and clients.
    Create COM objects with dual interfaces.

Prerequisites

Before beginning this course, students should be able to:

    Describe and use the following C++ fundamentals:
        Constructors and destructors
        Virtual function
        Conversion functions
        Function overloading
        Operator overloading
        Accessors
        Single and multiple inheritance
        Templates
    Use the Windows® environment and use the Visual Studio® integrated development environment.

Course Outline

Module 1: Introduction to COM

    List the major goals of COM.
    List the steps for creating a client of a COM object.
    Explain the significance of the CLSID and ProgID of a COM object.
    Create a client of a COM object.
    Explain how data is exchanged between a COM server and a COM client.

Module 2: Creating a COM Object

    Explain the concept of immutability in relation to interfaces.
    Explain, use, and generate a GUID (globally unique identifier).
    Describe the purpose and functionality of the IUnknown interface.
    Explain reference counting and its implications.
    Create a COM object.
    Create a COM object server.
    Register a COM object server.

Module 3: Implementing Multiple Interfaces

    Use multiple inheritance to implement COM objects with multiple interfaces.
    Use embedding to implement COM objects with multiple interfaces.

Module 4: Introduction to ATL

    Explain the benefits of using ATL to create COM objects and object servers.
    Use the ATL COM AppWizard to create a COM object server.
    Use the ATL Object Wizard to add a simple COM object with a custom interface to ATL COM object server.
    Use Visual C++ extensions to create a client of a COM object.
    Explain the significance of each of the following in an ATL COM project:
        COM map
        Object map
        CComModule
        CComObjectRoot
        CComCoClass

Module 5: Automation

    Explain the benefits of Automation.
    Compare the methods and properties of an Automation object to the behaviors and attributes of a class.
    Implement Automation for a COM object.
    Use structures with Automation objects.
    Create a client application for an Automation object.

Module 6: Dual Interfaces

    Describe the need for dual interfaces.
    Explain the benefits and limitations of creating dual interfaces.
    Create a COM object with dual interface using ATL.
    Create a client for a COM object with a dual interface.
    Implement multiple dual interfaces.

Module 7: Handling Events

    Explain how events work in COM from a server and client perspective.
    Enable a COM object to fire events using dispinterfaces and custom interfaces.
    Create clients in Visual Basic C++ that can receive events from a COM object.

Module 8: Creating Controls Using ATL

    List the types of controls supported by ATL.
    Create a control using the ATL Object Wizard.
    Add methods and properties to a control and implement them.
    Modify the OnDraw method to draw graphical output for a control.
    Register and license a control.

Module 9: Reusing COM Objects

    Design a COM containment and COM aggregation.
    Implement containment and aggregation to reuse COM objects.
    Create a tear-off interface.

Module 10: Custom Interfaces

    List the advantages and disadvantages of using custom interfaces.
    Create a custom interface using ATL.
    List the techniques available for improving memory usage and performance of a remote COM server.
    Explain the standard and custom marshaling techniques.

Module 11: Threading Models

    Describe the limitations of single-threaded applications.
    Explain the differences between single-threaded apartment model, multi-threaded apartment model, and mixed threading model.
    Explain how mixed threading models can cause marshaling issues.
    Register a threading model.

Module 12: Collections

    Explain the role of enumerators in using a collection.
    Create and implement a collection.
    Write client-side code to use a collection.