并且为这些函数通向 com 库提供了 com 的二进制指针。然后 com 使这些函数运行在

请求了一个指向该接口的任何客户端。

Interfaces and Interface Implementations

COM 在接口的定义和实现上有根本的差别。一个接口实际上是由一组定义了用法的相

联系的函数原型组成，只是他不能够被实现。这些函数原型就相当于 C++ 中含有纯虚拟函数的基类。一个接口定义制定了接口的成员函数、调用方法、返回类型、他们的参数的数量和类型，这些函数要干什么。但是这里并没有与接口实现相关的东西。一个接口的实现就是程序员在一个借口定义上提供的执行相关动作的代码。

     一个接口的实现就是程序员在一个借口定义上提供的执行相关动作的代码。客户调用完全是决定于接口的定义。

Interface Pointers and Interfaces

接口实现的一个实例，实际上就是一个指向一组方法的指针，即是指指向一个接口的函 数表，该函数表引用了该接口所有方法的实现。

     每个接口，是一个固定的一组方法的集合，在运行时通过 globally unique interface identifier (IID) 来定位。这里， IID 是 com 支持的 globally unique identifier (GUID) 的特殊的实例。这样做就不会产生单一系统上相同名字、接口的多个版本的 COM 之间的冲突了。

• 一个COM接口与C++类是不一样的；
• 一个COM接口不是一个对象——他只是简单的关联一组函数，是客户和程序之间通信的二进制标准。只要他提供了指向借口方法的指针，这个对象就可以用任何语言来实现他。；
• COM接口十强类型的——每个接口有他自己的借口标识符；

·         COM接口的不变性——你不能够用老版本的接口标识符定义新的版本，接口的IID定义的接口合同是明确的、唯一的 。

IUnknown and Interface Inheritance

     继承在 COM 里并不意味着代码的重用。因为接口没有实现关联，借口继承并意味着代码继承。他的意思仅仅是，一个接口同一个合同关联，就像 C++ 的纯虚拟基类的创建和修改样，可以添加方法或者更进一步的加强方法的使用。在 COM 里没有选择性继承。如果一个接口由另一个接口继承的话，他就包含了另一个接口定义的所有的方法。

Using and Implementing IUnknown

    COM 为实现和使用对象和对象的内部通信提供了一个丰富的标准集合。对IUnknown接口的实现和使用的细节，请参见下面主题：QueryInterface: Navigating in an Object 。 

Rules for Implementing QueryInterface

管理实现一个COM对象的 IUnknown::QueryInterface 方法的三个主要规则：

    1．对象必须要有一个标识符；  

    2．一个对象实例的接口集合必须是静态的（static）；  

    3．在对象中从任何一个其他的接口查询此接口都应该成功。  

通过引用计数来管理对象的生命周期

     使用 AddRef （）     //增加引用 
                Realase（）   //减少引用

BEGIN_MSG_MAP( CMyMainWindow )
   COMMAND_ID_HANDLER( ID_HELP_ABOUT, onHelpAbout )
   ...

LRESULT onHelpAbout( WORD, WORD, HWND, BOOL& )
{
   CSimpleDialog<IDD_DIALOG1> dlg;
   int ret = dlg.DoModal();
   return 0;
}

class CMyModelessDialog: public CDialogImpl
{

public:
   enum { IDD = IDD_DIALOG1 };

BEGIN_MSG_MAP( CMyDialog )
   MESSAGE_HANDLER( WM_INITDIALOG, OnInitDialog )
   MESSAGE_HANDLER( WM_CLOSE, OnClose )
   ...
END_MSG_MAP()

LRESULT OnClose( UINT, WPARAM, LPARAM, BOOL& )
{
   DestroyWindow();
   return 0;
}
...
}; // CMyModelessDialog

CMyModelessDialog dlg;
dlg.Create( wndParent );

dlg.ShowWindow( SW_SHOW );

#include "atlbase.h"
CComModule _Module;
#include "atlwin.h"
#include "resource.h"

class CMyWindow: public CWindowImpl<CMyWindow>
{
public:
   DECLARE_WND_SUPERCLASS( "MyWindow", "listbox" )

   BEGIN_MSG_MAP( CMyWindow )
      MESSAGE_HANDLER( WM_DESTROY, OnDestroy )
   END_MSG_MAP()

   LRESULT OnDestroy( UINT, WPARAM, LPARAM, BOOL& )
   {
      PostQuitMessage( 0 );
      return 0;
   }

   void DoSomething( LPCTSTR s )
   {
      SendMessage( LB_ADDSTRING, 0, reinterpret_cast<LPARAM>(s) );
   }
};

class CMyDialog: public CDialogImpl<CMyDialog>
{
public:
   enum { IDD = IDD_DIALOG1 };
   BEGIN_MSG_MAP( CMyDialog )
      COMMAND_ID_HANDLER( IDC_BUTTON1, OnButton )
      MESSAGE_HANDLER( WM_INITDIALOG, OnInitDialog )
      MESSAGE_HANDLER( WM_CLOSE, OnClose )
   END_MSG_MAP()

   LRESULT OnButton(WORD, WORD, HWND, BOOL&)
   {
      char buf[100];
      m_ed.GetWindowText( buf, 100 );
      m_owner.DoSomething( buf );
      return 0;
   }

   LRESULT OnInitDialog( UINT, WPARAM, LPARAM, BOOL& )
   {
      m_owner.Attach( GetParent() );
      CenterWindow( m_owner );
      m_ed = GetDlgItem( IDC_EDIT1 );
      return TRUE;
   }

   LRESULT OnClose( UINT, WPARAM, LPARAM, BOOL& )
   {
      DestroyWindow();
      m_owner.Detach();
      return 0;
   }

   CMyWindow m_owner;
   CWindow m_ed;
};

CMyDialog dlg;

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
   _Module.Init( NULL, hInstance );
   CMyWindow win;
   win.Create( NULL, CWindow::rcDefault, _T("modeless dialog test"),
      WS_OVERLAPPEDWINDOW|WS_VISIBLE );
   dlg.Create( win );
   dlg.ShowWindow( SW_SHOW );

   MSG msg;
   while( GetMessage( &msg, NULL, 0, 0 ) ){
      if( !IsWindow(dlg) || !dlg.IsDialogMessage( &msg ) ){
         DispatchMessage( &msg );
      }
   }
   _Module.Term();
   return 0;
}

CMyWindow wnd;
wnd.Create( NULL, CWindow::rcDefault, _T("Hello"),
   WS_OVERLAPPEDWINDOW|WS_VISIBLE );

typedef CWinTraits<WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN
   |WS_CLIPSIBLINGS, 0> CControlWinTraits;

template <class T,
          class TBase = CWindow,
          class TWinTraits = CControlWinTraits>
class CWindowImpl : public ...

typedef CWinTraits<WS_OVERLAPPEDWINDOW|WS_VISIBLE,0>
   MyTraits;

class CMyWindow: public CWindowImpl<CMyWindow,CWindow,MyTraits>
{...};

class CMyWindow: public CWindowImpl<
   CMyWindow,
   CWindow,
   CWinTraits<WS_OVERLAPPEDWINDOW|WS_VISIBLE,0> 
>
{...};

CMyWindow wnd;
wnd.Create( NULL, CWindow::rcDefault, _T("Hello") );
// style: WS_OVERLAPPEDWINDOW|WS_VISIBLE

ovwnd.Create( NULL, CWindow::rcDefault, _T("Hello"),
   WS_OVERLAPPEDWINDOW ); // not visible

class CClientWindow: public CWindowImpl<CClientWindow, CWindow,
   CWinTraits< WS_OVERLAPPEDWINDOW|WS_VISIBLE, WS_EX_CLIENTEDGE > >
{...};

DECLARE_WND_CLASS("my window class");

DECLARE_WND_CLASS_EX(
   "my window class",
   CS_HREDRAW|CS_VREDRAW|CS_DBLCLKS, // default style
   COLOR_WINDOW                      // default color
);

class CMyWindow: public CWindowImpl<CMyWindow>
{
public:
   DECLARE_WND_CLASS_EX(
      "my window class",       // class name
      CS_HREDRAW|CS_VREDRAW,   // class style
      COLOR_WINDOW             // background color
   );
   BEGIN_MSG_MAP(CMyWindow)
      ...

#define DECLARE_WND_CLASS(WndClassName) \
static CWndClassInfo& GetWndClassInfo() \
{ \
   static CWndClassInfo wc = \
   { \
      { sizeof(WNDCLASSEX), CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS, \
        StartWindowProc, \
        0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, \
        WndClassName, NULL }, \
      NULL, NULL, IDC_ARROW, TRUE, 0, _T("") \
   }; \
   return wc; \
}

struct CWndClassInfo
{
   struct WNDCLASSEX
   {
      UINT        cbSize;
      UINT        style;
      WNDPROC     lpfnWndProc;
      int         cbClsExtra;
      int         cbWndExtra;
      HINSTANCE   hInstance;
      HICON       hIcon;
      HCURSOR     hCursor;
      HBRUSH      hbrBackground;
      LPCSTR      lpszMenuName;
      LPCSTR      lpszClassName;
      HICON       hIconSm;
   } m_wc;
   LPCSTR m_lpszOrigName;
   WNDPROC pWndProc;
   LPCSTR m_lpszCursorID;
   BOOL m_bSystemCursor;
   ATOM m_atom;
   CHAR m_szAutoName[13];
   ATOM Register(WNDPROC* p);
};

class CMyWindow: public CWindowImpl<CMyWindow>
{
public:
   static CWndClassInfo& GetWndClassInfo()
   {
      // a manual DECLARE_WND_CLASS macro expansion
      // modified to specify an application-defined cursor:
      static CWndClassInfo wc =
      {
         { sizeof(WNDCLASSEX), CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS, 
            StartWindowProc,
            0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, 
            "MyWindow", NULL },
         NULL, NULL, MAKEINTRESOURCE(IDC_CURSOR1), FALSE, 0, _T("")
      };
      return wc;
   }
   ...

class CMyWindow: public CWindowImpl
{
   CContainedWindow m_contained;
public:
   CMyWindow(): m_contained( _T("edit"), this, 99 )
   {
   }
   ...

BEGIN_MSG_MAP( CMyWindow )
   MESSAGE_HANDLER( WM_CREATE, OnCreate )
   MESSAGE_HANDLER( WM_DESTROY, OnDestroy )
ALT_MSG_MAP( 99 ) // contained window''s messages come here...
   MESSAGE_HANDLER( WM_CHAR, OnChar )
END_MSG_MAP()

LRESULT OnCreate( UINT, WPARAM, LPARAM, BOOL& )
{
   RECT rc = { 10, 10, 200, 35 };
   m_contained.Create( *this, rc, _T("non-numeric edit"),
      WS_CHILD|WS_VISIBLE|WS_BORDER, 0, 666 );
   return 0;
}

LRESULT OnChar( UINT, WPARAM wParam, LPARAM, BOOL& bHandled )
   {
   TCHAR ch = wParam;
   if( _T(''0'') <= ch && ch <= _T(''9'') )
      MessageBeep( 0 );
   else
      bHandled = FALSE;
   return 0;
   }

LRESULT OnDestroy( UINT, WPARAM, LPARAM, BOOL& )
   {
   PostQuitMessage( 0 );
   return 0;
   }
};

class CMyDialog: public CDialogImpl<CMyDialog>
{
public:
   enum { IDD = IDD_DIALOG1 };
// contained window is an edit control:
   CMyDialog(): m_contained( "edit", this, 123 )
   {
   }

   BEGIN_MSG_MAP( CMyDialog )
      MESSAGE_HANDLER( WM_INITDIALOG, OnInitDialog )
   ALT_MSG_MAP( 123 ) // contained window''s messages come here...
      MESSAGE_HANDLER( WM_CHAR, OnChar )
   END_MSG_MAP()

   LRESULT OnInitDialog( UINT, WPARAM, LPARAM, BOOL& bHandled )
   {
   // when the dialog box is created, subclass its edit control:
      m_contained.SubclassWindow( GetDlgItem(IDC_EDIT1) );
      bHandled = FALSE;
      return 0;
   }

   LRESULT OnChar( UINT, WPARAM wParam, LPARAM, BOOL& bHandled )
   {
      TCHAR ch = wParam;
      if( _T(''0'') <= ch && ch <= _T(''9'') )
         MessageBeep( 0 );
      else
         bHandled = FALSE;
      return 0;
   }

   CContainedWindow m_contained;
};

class CParentWindow: CWindowImpl<CParentWindow>
{
   // 假设这个窗口有一个按钮型的子窗口，
   // 并且其 ID 为 ID_BUTTON
   BEGIN_MSG_MAP( CParentWindow )
      COMMAND_ID_HANDLER( ID_BUTTON, OnButton )
      MESSAGE_HANDLER( WM_CTLCOLORBUTTON, OnColorButton )
      ...

class CParentWindow: CWindowImpl
{
   BEGIN_MSG_MAP( CParentWindow )
      MESSAGE_HANDLER( WM_CREATE, OnCreate )
      MESSAGE_HANDLER( WM_DESTROY, OnDestroy )
      ...other messages that CParentWindow will handle...
      REFLECT_NOTIFICATIONS()
   END_MSG_MAP()
   ...

class CHandlesItsOwnMessages: CWindowImpl<CHandlesItsOwnMessage>
{
public:
   DECLARE_WND_SUPERCLASS( _T("Superbutton"), _T("button") )
   BEGIN_MSG_MAP( CHandlesItsOwnMessage )
      MESSAGE_HANDLER( OCM_COMMAND, OnCommand )
      MESSAGE_HANDLER( OCM_CTLCOLORBUTTON, OnColorButton )
      DEFAULT_REFLECTION_HANDLER()
   END_MSG_MAP()
   ...

// in CParentWindow:
   CHandlesItsOwnMessages m_button;
   LRESULT OnCreate( UINT, WPARAM, LPARAM, BOOL& )
   {
      RECT rc; // initialize appropriately
      m_button.Create( *this, rc, _T("click me"), WS_CHILD|WS_VISIBLE );
      ...

m_button.SubclassWindow( GetDlgItem(ID_BUTTON) );

#include "stdafx.h"
#include "resource.h"

CComModule _Module;

class CStaticLink : public CWindowImpl<CStaticLink> {
/*
   Based on CStaticLink by Paul DiLascia, C++ Q&A, Microsoft Systems
   Journal 12/1997.
   Turns static controls into clickable "links" -- when the control is
   clicked, the file/program/webpage named in the control''s text (or
   set by SetLinkText()) is opened via ShellExecute().  Static control
   can be either text or graphic (bitmap, icon, etc.).
*/
public:
   DECLARE_WND_SUPERCLASS( _T("StaticLink"), _T("Static") )

   CStaticLink() :
      m_colorUnvisited( RGB(0,0,255) ),
      m_colorVisited( RGB(128,0,128) ),
      m_bVisited( FALSE ),
      m_hFont( NULL )
   {
   }

   void SetLinkText( LPCTSTR szLink ) {
      USES_CONVERSION;
      m_bstrLink = T2OLE( szLink );
   }

   BEGIN_MSG_MAP(CStaticLink)
      // uses message reflection: WM_* comes back as OCM_*
      MESSAGE_HANDLER( OCM_COMMAND, OnCommand )
      MESSAGE_HANDLER( OCM_CTLCOLORSTATIC, OnCtlColor )
      MESSAGE_HANDLER( WM_DESTROY, OnDestroy ) // not a reflected message
      DEFAULT_REFLECTION_HANDLER()
   END_MSG_MAP()

   LRESULT OnDestroy( UINT, WPARAM, LPARAM, BOOL& ) {
      if( m_hFont ) DeleteObject( m_hFont );
      return 0;
   }

   LRESULT OnCommand( UINT, WPARAM wParam, LPARAM, BOOL& ) {
      USES_CONVERSION;
      int code = HIWORD( wParam );
      if( code == STN_CLICKED || code == STN_DBLCLK ){
         if( m_bstrLink.Length() == 0 ){
            GetWindowText( &m_bstrLink );
         }
         if( (int)ShellExecute( *this, _T("open"),
            OLE2T(m_bstrLink), NULL, NULL, SW_SHOWNORMAL ) > 32 ){
            m_bVisited = TRUE;   // return codes > 32 => success
            Invalidate();
         }else{
            MessageBeep( 0 );
            ATLTRACE( _T("Error: CStaticLink couldn''t open file") );
         }
      }
      return 0;
   }

   LRESULT OnCtlColor( UINT, WPARAM wParam, LPARAM, BOOL& ) {
      // notify bit must be set to get STN_* notifications
      ModifyStyle( 0, SS_NOTIFY );
      HBRUSH hBr = NULL;
      if( (GetStyle() & 0xff) <= SS_RIGHT ){
         // it''s a text control: set up font and colors
         if( !m_hFont ){
            LOGFONT lf;
            GetObject( GetFont(), sizeof(lf), &lf );
            lf.lfUnderline = TRUE;
            m_hFont = CreateFontIndirect( &lf );
         }
         HDC hDC = (HDC)wParam;
         SelectObject( hDC, m_hFont );
         SetTextColor( hDC, m_bVisited ? m_colorVisited
                                       : m_colorUnvisited );
         SetBkMode( hDC, TRANSPARENT );
         hBr = (HBRUSH)GetStockObject( HOLLOW_BRUSH );
      }
      return (LRESULT)hBr;
   }

private:
   COLORREF m_colorUnvisited;
   COLORREF m_colorVisited;
   BOOL m_bVisited;
   HFONT m_hFont;
   CComBSTR m_bstrLink;
}; // CStaticLink

class CReflectDlg : public CDialogImpl<CReflectDlg> {
public:
   enum { IDD = IDD_DIALOG1 };
   
   BEGIN_MSG_MAP(CReflectDlg)
      COMMAND_RANGE_HANDLER( IDOK, IDCANCEL, OnClose )
      MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
      REFLECT_NOTIFICATIONS()      // reflect messages back to static links
   END_MSG_MAP()
      
   LRESULT OnInitDialog(UINT, WPARAM, LPARAM, BOOL&)
   {
      CenterWindow( GetParent() );
      // a textual static control:
      s1.SubclassWindow( GetDlgItem(IDS_TEST1) );
      // a static control displaying an icon
      s2.SubclassWindow( GetDlgItem(IDS_TEST2) );
      // set the icon''s link
      s2.SetLinkText( _T("http://www.microsoft.com") );
      return 1;
   }
   
   LRESULT OnClose(UINT, WPARAM wID, HWND, BOOL& )
   {
      ::EndDialog( m_hWnd, wID );
      return 0;
   }
private:
   CStaticLink s1, s2;
}; // CReflectDlg

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
   _Module.Init( NULL, hInstance );

   CReflectDlg dlg;
   dlg.DoModal();

   _Module.Term();
   return 0;
}

HWND hWnd = ::CreateWindow( "button", "Click me", 
WS_CHILD, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, NULL, NULL, hInstance, NULL );
::ShowWindow( hWnd, nCmdShow );
::UpdateWindow( hWnd );

CWindow win;
win.Create( "button", NULL, CWindow::rcDefault, "Click me",
WS_CHILD );
win.ShowWindow( nCmdShow );
win.UpdateWindow();

CWindow win;

win.Create( "button", NULL, CWindow::rcDefault, "Click me",
WS_CHILD );

HWND hWnd = CreateWindow( szWndClass, "Main window",
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
CW_USEDEFAULT, NULL, NULL, hInstance, NULL );
// 下面的方法中可以任选一种：
//      CWindow win( hWnd );      // 通过构造函数关联
// 或
//      CWindow win;
//      win = hWnd;               // 通过赋值操作符关联
// 或
//      CWindow win;
//      win.Attach( hWnd );      // 使用Attach()方法关联
win.CenterWindow();      // 现在可以使用win对象来代替hWnd进行操作
win.ShowWindow( nCmdShow );
win.UpdateWindow();

::ShowWindow( win, nCmdShow );      // 此API函数本来要求HWND类型的参数

class CMyWindow : public CWindowImpl
{

BEGIN_MSG_MAP(CMyWindow)
   MESSAGE_HANDLER(WM_PAINT,OnPaint)
   MESSAGE_HANDLER(WM_CREATE,OnCreate)
   MESSAGE_HANDLER(WM_DESTROY,OnDestroy)
END_MSG_MAP()

MESSAGE_HANDLER(WM_PAINT,OnPaint)

LRESULT OnPaint(
   UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{ ... 
}
LRESULT OnCreate(
   UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{ ...
}
LRESULT OnDestroy(
   UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled )
{ ... 
}
}; // CmyWindow

CMyWindow wnd;      // 构造一个 CMyWindow 类的对象
wnd.Create( NULL, CWindow::rcDefault, _T("Hello"),
   WS_OVERLAPPEDWINDOW|WS_VISIBLE );

#include <atlbase.h>
extern CComModule _Module;
#include <atlwin.h>

#include "stdafx.h"
CComModule _Module;
class CMyWindow : public CWindowImpl<CMyWindow> {
   BEGIN_MSG_MAP( CMyWindow )
      MESSAGE_HANDLER( WM_PAINT, OnPaint )
      MESSAGE_HANDLER( WM_DESTROY, OnDestroy )
   END_MSG_MAP()

   LRESULT OnPaint( UINT, WPARAM, LPARAM, BOOL& ){
      PAINTSTRUCT ps;
      HDC hDC = GetDC();
      BeginPaint( &ps );
      TextOut( hDC, 0, 0, _T("Hello world"), 11 );
      EndPaint( &ps );
      return 0;
   }

   LRESULT OnDestroy( UINT, WPARAM, LPARAM, BOOL& ){
      PostQuitMessage( 0 );
      return 0;
   }
};

int APIENTRY WinMain( HINSTANCE hInstance, HINSTANCE, LPSTR, int )
{
   _Module.Init( NULL, hInstance );

   CMyWindow wnd;
   wnd.Create( NULL, CWindow::rcDefault, _T("Hello"),
      WS_OVERLAPPEDWINDOW|WS_VISIBLE );

   MSG msg;
   while( GetMessage( &msg, NULL, 0, 0 ) ){
      TranslateMessage( &msg );
      DispatchMessage( &msg );
   }

   _Module.Term();
   return msg.wParam;
}

在这个示例程序中，CmyWindow是从CWindowImpl派生的，它的消息映射捕获了两个消息WM_PAINT和WM_DESTROY，当收到WM_PAINT消息时，它的成员函数OnPaint处理这个消息并在窗口上输出“Hello world”，当收到WM_DESTROY消息时，也就是当用户关闭这个窗口的时候，调用OnDestroy函数处理这个消息，在OnDestroy函数中调用PostQuitMessage来结束消息循环。

WinMain函数中创建了一个CmyWindow类的实例并实现了一个标准的消息循环。（有一些地方，我们必须遵循ATL的规范，比如在这里我们必须使用_Module。）

消息映射：
有三组用于消息映射的宏，他们分别是：

• 窗口消息映射宏，用于所有的窗口消息（如WM_CREATE、WM_PAINT等）；
• 命令消息映射宏，专用于WM_COMMAND消息（比如由控件或菜单发出的消息）；
• 通知消息映射宏，专用于WM_NOTUFY消息（通常由通用控件发出此消息，比如工具栏控件或列表视图控件）

窗口消息映射宏：
有两个窗口消息映射宏，他们分别是：

• MESSAGE_HANDLER
• MESSAGE_RANGE_HANDLER

第一个宏将一个特定的消息映射到相应的处理函数；第二个宏将一组消息映射到一个处理函数。消息处理函数都要求具有如下的原形：

LRESULT MessageHandler(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled);

其中，参数uMsg是消息标识，wParam和lParam是两个附加与消息的参数，（他们的具体意义取决与消息类别。）

消息处理函数使用bHandled来标志消息是否已经被完全捕获，如果bHandled被设置成FALSE，程序将继续在消息映射表的后续部分查找这个消息的其它处理函数。这个特性使得我们对一个消息使用多个处理函数成为可能。什么时候需要对一个消息使用多个处理函数呢？可能是在对多个类链接时，也可能是我们只想对一个消息做出响应但是并不真正捕获它。在处理函数被调用之前，bHandled被置为TRUE，所以如果我们不在函数的结尾显式地将它置为FALSE，则消息映射表的后续部分不会被继续查找，也不会有其它的处理函数被调用。

命令消息映射宏：
命令消息映射宏只处理命令消息（WM_COMMAND消息），但是它能让我们根据消息类型或者发送命令消息的控件ID来指定消息处理函数。

• COMMAND_HANDLER映射一个特定控件的一条特定消息到一个处理函数；
• COMMAND_ID_HANDLER映射一个特定控件的所有消息到一个处理函数；
• COMMAND_CODE_HANDLER映射任意控件的一个特定消息到一个处理函数；
• COMMAND_RANGE_HANDLER映射一定范围内的控件的所有消息到一个处理函数；
• COMMAND_RANGE_CODE_HANDLER映射一定范围内的控件的一条特定消息到一个处理函数。

命令消息处理函数应该具有如下的原形：

LRESULT CommandHandler(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled);

其中，参数wNotifyCode代表消息代码，wID代表发送消息的控件的ID，hWndCtl代表发送消息的控件的窗口句柄，bHandled的意义如前所述。

通知消息映射宏：
通知消息映射宏用来处理通知消息（WM_NOTUFY消息），它根据通知消息的类型和发送通知消息的控件的不同将消息映射到不同的处理函数，这些宏与前面讲的命令消息映射宏是等价的，唯一的不同就是它处理的是通知消息而不是命令消息。

• NOTIFY_HANDLER
• NOTIFY_ID_HANDLER
• NOTIFY_CODE_HANDLER
• NOTIFY_RANGE_HANDLER
• NOTIFY_RANGE_CODE_HANDLER

通知消息处理函数都需要如下的原形：

LRESULT NotifyHandler(int idCtrl, LPNMHDR pnmh, BOOL& bHandled);

NOTIFY_HANDLER( ID_LISTVIEW, LVN_ENDLABELEDIT, OnEndLabelEdit)

LRESULT OnEndLabelEdit(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
   // The item is -1 if editing is being canceled. 
   if ( ((NMLVDISPINFO*)pnmh)->item.iItem == -1) return FALSE; 
   ...

class CBase: public CWindowImpl< CBase >
// simple base window class: shuts down app when closed
{
   BEGIN_MSG_MAP( CBase )
      MESSAGE_HANDLER( WM_DESTROY, OnDestroy )
   END_MSG_MAP()

   LRESULT OnDestroy( UINT, WPARAM, LPARAM, BOOL& )
   {
      PostQuitMessage( 0 );
      return 0;
   }
};

class CDerived: public CBase
// derived from CBase; handles mouse button events
{
   BEGIN_MSG_MAP( CDerived )
      MESSAGE_HANDLER( WM_LBUTTONDOWN, OnButtonDown )
   END_MSG_MAP()

   LRESULT OnButtonDown( UINT, WPARAM, LPARAM, BOOL& )
   {
      ATLTRACE( "button down\n" );
      return 0;
   }
};

// in WinMain():
   ...
   CDerived win;
   win.Create( NULL, CWindow::rcDefault, "derived window" );

BEGIN_MSG_MAP( CDerived )
   MESSAGE_HANDLER( WM_LBUTTONDOWN, OnButtonDown )
   CHAIN_MSG_MAP( CBase ) // 链接到基类
END_MSG_MAP()

// in class CBase:
   BEGIN_MSG_MAP( CBase )
      MESSAGE_HANDLER( WM_CREATE, OnCreate1 )
      MESSAGE_HANDLER( WM_PAINT, OnPaint1 )
      ALT_MSG_MAP( 100 )
      MESSAGE_HANDLER( WM_CREATE, OnCreate2 )
      MESSAGE_HANDLER( WM_PAINT, OnPaint2 )
      ALT_MSG_MAP( 101)
      MESSAGE_HANDLER( WM_CREATE, OnCreate3 )
      MESSAGE_HANDLER( WM_PAINT, OnPaint3 )
   END_MSG_MAP()

class CDerived: public CBase {
   BEGIN_MSG_MAP( CDerived )
      CHAIN_MSG_MAP_ALT( CBase, 100 )
   END_MSG_MAP()
   ...

class CBeepButton: public CWindowImpl< CBeepButton >
{
public:
   DECLARE_WND_SUPERCLASS( _T("BeepButton"), _T("Button") )
   BEGIN_MSG_MAP( CBeepButton )
      MESSAGE_HANDLER( WM_LBUTTONDOWN, OnLButtonDown )
   END_MSG_MAP()

   LRESULT OnLButtonDown( UINT, WPARAM, LPARAM, BOOL& bHandled )
   {
      MessageBeep( MB_ICONASTERISK );
      bHandled = FALSE; // alternatively: DefWindowProc()
      return 0;
   }
}; // CBeepButton

const int ID_BUTTON1 = 101;
const int ID_BUTTON2 = 102;

class CMyWindow: public CWindowImpl< CMyWindow, CWindow,
CWinTraits<WS_OVERLAPPEDWINDOW|WS_VISIBLE> >
{
   CBeepButton b1, b2;

   BEGIN_MSG_MAP( CMyWindow )
      MESSAGE_HANDLER( WM_CREATE, OnCreate )
      COMMAND_CODE_HANDLER( BN_CLICKED, onClick )
   END_MSG_MAP()

   LRESULT onClick(WORD wNotifyCode, WORD wID, HWND hWndCtl,
      BOOL& bHandled)
   {
      ATLTRACE( "Control %d clicked\n", wID );
      return 0;
   }

   LRESULT OnCreate( UINT, WPARAM, LPARAM, BOOL& )
   {
      RECT r1 = { 10, 10, 250, 80 };
      b1.Create(*this, r1, "beep1", WS_CHILD|WS_VISIBLE, 0, ID_BUTTON1);
      RECT r2 = { 10, 110, 250, 180 };
      b2.Create(*this, r2, "beep2", WS_CHILD|WS_VISIBLE, 0, ID_BUTTON2);
      return 0;
   }
}; // CMyWindow

class CNoNumEdit: public CWindowImpl< CNoNumEdit >
{
   BEGIN_MSG_MAP( CNoNumEdit )
      MESSAGE_HANDLER( WM_CHAR, OnChar )
   END_MSG_MAP()

   LRESULT OnChar( UINT, WPARAM wParam, LPARAM, BOOL& bHandled )
   {
      TCHAR ch = wParam;
      if( _T(''0'') <= ch && ch <= _T(''9'') )
         MessageBeep( 0 );
      else
         bHandled = FALSE;
      return 0;
   }
};

class CMyDialog: public CDialogImpl<CMyDialog>
{
public:
   enum { IDD = IDD_DIALOG1 };
   BEGIN_MSG_MAP( CMyDialog )
      MESSAGE_HANDLER( WM_INITDIALOG, OnInitDialog )
   END_MSG_MAP()

   LRESULT OnInitDialog( UINT, WPARAM, LPARAM, BOOL& )
   {
      ed.SubclassWindow( GetDlgItem( IDC_EDIT1 ) );
      return 0;
   }

   CNoNumEdit ed;
};

void f(void) {
   IUnknown *pUnk = 0;
   // 调用 
   HRESULT hr = GetSomeObject(&pUnk);
   if (SUCCEEDED(hr)) {
   // 使用
     UseSomeObject(pUnk);
 // 释放
     pUnk->Release();
   }
}
    

void f(void) {
  IUnknown *rgpUnk[3];
  HRESULT hr = GetObject(rgpUnk);
  if (SUCCEEDED(hr)) {
    hr = GetObject(rgpUnk + 1);
    if (SUCCEEDED(hr)) {
      hr = GetObject(rgpUnk + 2);
      if (SUCCEEDED(hr)) {
        UseObjects(rgpUnk[0], rgpUnk[1],
                     rgpUnk[2]);
        rgpUnk[2]->Release();
      }
      rgpUnk[1]->Release();
    }
    rgpUnk[0]->Release();
  }
}
    

void f(void) {
   IUnknown *rgpUnk[3];
   ZeroMemory(rgpUnk, sizeof(rgpUnk));
   if (FAILED(GetObject(rgpUnk))) 
     goto cleanup;
   if (FAILED(GetObject(rgpUnk+1))) 
     goto cleanup;
   if (FAILED(GetObject(rgpUnk+2))) 
     goto cleanup;
 
   UseObjects(rgpUnk[0], rgpUnk[1], rgpUnk[2]);
 
 cleanup:
   if (rgpUnk[0]) rgpUnk[0]->Release();
   if (rgpUnk[1]) rgpUnk[1]->Release();
   if (rgpUnk[2]) rgpUnk[2]->Release();
}    

void f(void) {
   IUnknown *rgpUnk[3];
   ZeroMemory(rgpUnk, sizeof(rgpUnk));
   __try {
    if (FAILED(GetObject(rgpUnk))) leave;
    if (FAILED(GetObject(rgpUnk+1))) leave;
    if (FAILED(GetObject(rgpUnk+2))) leave;
 
    UseObjects(rgpUnk[0], rgpUnk[1], rgpUnk[2]);
   } __finally {
    if (rgpUnk[0]) rgpUnk[0]->Release();
    if (rgpUnk[1]) rgpUnk[1]->Release();
    if (rgpUnk[2]) rgpUnk[2]->Release();
}

      CComPtr<IUnknown> unk;
      CComPtr<IClassFactory> cf;

void f(IUnknown *pUnk1, IUnknown *pUnk2) {
    // 如果非空，构造函数调用pUnk1的AddRef 
    CComPtr unk1(pUnk1);
    // 如果非空，构造函数调用unk1.p的AddRef
    CComPtr unk2 = unk1;
    // 如果非空，operator= 调用unk1.p的Release并且
    //如果非空，调用unk2.p的AddRef
    unk1 = unk2;
    //如果非空，析构函数释放unk1 和 unk2
}

void f(IUnknown *pUnkCO) {
    
    CComPtr cf;
    
    HRESULT hr;
    
    // 使用操作符 & 获得对 &cf.p 的存取
    hr = pUnkCO->QueryInterface(IID_IClassFactory,(void**)&cf);
    if (FAILED(hr)) throw hr;
    
    CComPtr unk;
    
    // 操作符 -> 获得对cf.p的存取
    // 操作符 & 获得对 &unk.p的存取
    hr = cf->CreateInstance(0, IID_IUnknown, (void**)&unk);
    
    if (FAILED(hr)) throw hr;
    
    // 操作符 IUnknown * 返回 unk.p
    UseObject(unk);
    
    // 析构函数释放unk.p 和 cf.p
}

void f(void) {
   CComPtr<IUnknown> rgpUnk[3];
   if (FAILED(GetObject(&rgpUnk[0]))) return;
   if (FAILED(GetObject(&rgpUnk[1]))) return;
   if (FAILED(GetObject(&rgpUnk[2]))) return;
   UseObjects(rgpUnk[0], rgpUnk[1], rgpUnk[2]);

      }

      CComQIPtr<IDataObject, &IID_IDataObject> do;
      CComQIPtr<IPersist, &IID_IPersist> p;

  
      void f(IPersist *pPersist) {
          CComQIPtr<IPersist, &IID_IPersist> p;
          // 同类赋值 - AddRef''s
          p = pPersist;
    
          CComQIPtr<IDataObject, &IID_IDataObject> do;
          // 异类赋值 - QueryInterface''s
          do = pPersist;
      }
 

      CComPtr<IUnknown> unk;
 

      CComQIPtr<IUnknown, &IID_IUnknown> unk;
 

 
void f(void) {
   IFoo *pFoo = 0;
   HRESULT hr = GetSomeObject(&pFoo);
   if (SUCCEEDED(hr)) {
      UseSomeObject(pFoo);
      pFoo->Release();
   }
} 

  void f(void) {
   CComPtr<IFoo> pFoo = 0;
   HRESULT hr = GetSomeObject(&pFoo);
   if (SUCCEEDED(hr)) {
      UseSomeObject(pFoo);
      pFoo->Release(); 
   }
}
 

 void f(IUnknown *pUnk) { 
    CComPtr unk = pUnk;
    // 隐式调用操作符IUnknown *()
    CoLockObjectExternal(unk, TRUE, TRUE);
}
 

HRESULT CFoo::Clone(IUnknown **ppUnk) { 
   CComPtr unk;
   CoCreateInstance(CLSID_Foo, 0, CLSCTX_ALL,
   IID_IUnknown, (void **) &unk);
   // 隐式调用操作符IUnknown *()
   *ppUnk = unk;
   return S_OK;
}

2个智能指针的模板包装类，CComPtr<> 和 CComQIPtr<>，这两个类都在 <atlbase.h> 中声明。CComQIPtr<>

包含了 CComPtr<>的所有功能，因此我们可以完全用 CComQIPtr<> 来使用智能接口指针，唯一要说明的一点就

是：CComQIPtr<> 由于使用了运算符的重载功能，它会自动帮我们调用QueryInterface()函数，因此

CComQIPtr<> 唯一的缺点就是不能定义 IUnknown * 指针。

　　  // 智能指针 smart pointer，按照匈牙利命名法，一般以 sp 开头来表示变量类型
　　  CComPtr < IUnknown > spUnk; // 正确
　　  // 假设 IFun 是一个接口类型
　　  CComPtr < IFun > spFun; // 正确
　　  CComQIPtr < IFun > spFun; // 正确
　　  CComQIPtr < IFun, &IID_IFun > spFun; // 正确
　　  CComQIPtr < IUnknown > spUnk; // 错误！CComQIPtr不能定义IUnknown指针
给智能指针赋值的方法：　　  CComQIPtr < IFun > spFun; // 调用构造函数，还没有赋值，被包装的内部

接口指针为 NULL
　　 
　　  CComQIPtr < IFun > spFun( pOtherInterface ); // 调用构造函数，内部接口指针赋值为
　　  // 通过 pOtherInterface 这个普通接口指针调用QueryInterface()得到的IFun接口指针
　　 
　　　　 
　　  CComQIPtr < IFun > spFun ( pUnknown ); // 调用构造函数，由IUnknown的QueryInterface()得到

IFun接口指针
　　 
　　  CComQIPtr < IFun > spFun = pOtherInterface; // = 运算符重载，含义和上面一样
　　  spFun = spOtherInterface; // 同上
　　  spFun = pUnknown; // 同上
　　 
　　  pUnknown->QueryInterface( IID_IFun, &sp ); // 也可以通过QueryInterface赋值
　　 
　　  // 智能指针赋值后，可以用条件语句判断是否合法有效
　　  if ( spFun ){}  // 如果指针有效
　　  if ( NULL != spFun ){} // 如果指针有效
　　 
　　  if ( !spFun ){}  // 如果指针无效
　　  if ( NULL == spFun ){} // 如果指针无效
智能指针调用函数的方法：　　  spFun.CoCreateInstance(...); // 等价与 API

函数::CoCreateInstance(...)
　　  spFun.QueryInterface(...); // 等价与 API 函数::QueryInterface()
　　 
　　  spFun->Add(...); // 调用内部接口指针的接口函数

　　  // 调用内部接口指针的QueryInterface()函数，其实效果和 spFun.QueryInterface(...) 一样
　　  spFun->QueryInterface(...); 
　　 
　　  spFun.Release(); // 释放内部的接口指针，同时内部指针赋值为 NULL
　　  spFun->Release(); // 错！！！一定不要这么使用。
　　  // 因为这个调用并不把内部指针清空，那么析构的时候会被再次释放（释放了两次）

typedef HRESULT (WINAPI * FREG)();
TCHAR szWorkPath[ MAX_PATH ];

::GetCurrentDirectory( sizeof(szWorkPath), szWorkPath );	// 保存当前进程的工作目录
::SetCurrentDirectory( 组件目录 );	// 切换到组件的目录

HMODULE hDLL = ::LoadLibrary( 组件文件名 );	// 动态装载组件
if(hDLL)
{
	FREG lpfunc = (FREG)::GetProcAddress( hDLL, _T("DllRegisterServer") );	// 取得注册函数指针
	// 如果是反注册，可以取得"DllUnregisterServer"函数指针
	if ( lpfunc )	lpfunc();	// 执行注册。这里为了简单，没有判断返回值
	::FreeLibrary(hDLL);
}

::SetCurrentDirectory(szWorkPath);	// 切换回原先的进程工作目录

　　下载示例程序后，请逐项浏览使用方法：

　　示例程序中都写有注释，请读者仔细阅读并同时参考 MSDN 的函数说明。这里，我给大家介绍一下“智能指针”：
　　对于操作原始的接口指针是比较麻烦的，需要我们自己控制引用记数、API 调用、异常处理。于是 ATL 提供了2个智能指针的模板包装类，CComPtr<> 和 CComQIPtr<>，这两个类都在 <atlbase.h> 中声明。CComQIPtr<> 包含了 CComPtr<>的所有功能，因此我们可以完全用 CComQIPtr<> 来使用智能接口指针，唯一要说明的一点就是：CComQIPtr<> 由于使用了运算符的重载功能，它会自动帮我们调用QueryInterface()函数，因此 CComQIPtr<> 唯一的缺点就是不能定义 IUnknown * 指针。

　　  // 智能指针 smart pointer，按照匈牙利命名法，一般以 sp 开头来表示变量类型
　　  CComPtr < IUnknown > spUnk;	// 正确
　　  // 假设 IFun 是一个接口类型
　　  CComPtr < IFun > spFun;	// 正确
　　  CComQIPtr < IFun > spFun;	// 正确
　　  CComQIPtr < IFun, &IID_IFun > spFun;	// 正确
　　  CComQIPtr < IUnknown > spUnk;	// 错误！CComQIPtr不能定义IUnknown指针

　　  CComQIPtr < IFun > spFun;	// 调用构造函数，还没有赋值，被包装的内部接口指针为 NULL
　　  
　　  CComQIPtr < IFun > spFun( pOtherInterface );	// 调用构造函数，内部接口指针赋值为
　　  // 通过 pOtherInterface 这个普通接口指针调用QueryInterface()得到的IFun接口指针
　　  
　　  CComQIPtr < IFun > spFun( spOtherInterface ); // 调用构造函数，内部接口指针赋值为
　　  // 通过 spOtherInterface 这个只能接口指针调用QueryInterface()得到的IFun接口指针
　　  
　　  CComQIPtr < IFun > spFun ( pUnknown );	// 调用构造函数，由IUnknown的QueryInterface()得到IFun接口指针
　　  
　　  CComQIPtr < IFun > spFun = pOtherInterface;	// = 运算符重载，含义和上面一样
　　  spFun = spOtherInterface;	// 同上
　　  spFun = pUnknown;	// 同上
　　  
　　  pUnknown->QueryInterface( IID_IFun, &sp );	// 也可以通过QueryInterface赋值
　　  
　　  // 智能指针赋值后，可以用条件语句判断是否合法有效
　　  if ( spFun ){}		// 如果指针有效
　　  if ( NULL != spFun ){}	// 如果指针有效
　　  
　　  if ( !spFun ){}		// 如果指针无效
　　  if ( NULL == spFun ){}	// 如果指针无效

　　  spFun.CoCreateInstance(...);	// 等价与 API 函数::CoCreateInstance(...)
　　  spFun.QueryInterface(...);	// 等价与 API 函数::QueryInterface()
　　  
　　  spFun->Add(...);	// 调用内部接口指针的接口函数

　　  // 调用内部接口指针的QueryInterface()函数，其实效果和 spFun.QueryInterface(...) 一样
　　  spFun->QueryInterface(...);	
　　  
　　  spFun.Release();	// 释放内部的接口指针，同时内部指针赋值为 NULL
　　  spFun->Release();	// 错！！！一定不要这么使用。
　　  // 因为这个调用并不把内部指针清空，那么析构的时候会被再次释放（释放了两次）

二、建立 ATL 工程

　　步骤2.1：建立一个解决方案。
　　步骤2.2：在 该解决方案中，新建一个 vc++ 的 ATL 项目。示例程序叫 Simple2，并选择DLL方式，见图一、图二。


图一、新建 ATL 项目


图二、选择非属性化的DLL组件类型

　　属性化 属性化编程，是未来的方向，但我们现在先不要选它。
　　动态链接库(DLL) 选择它。
　　可执行文件(EXE) 以后再讲。
　　服务(EXE) 表示建立一个系统服务组件程序，系统启动后就会加载并执行的程序。
　　允许合并代理/存根(stub)代码 选择该项表示把“代理/存根”代码合并到组件程序中，否则需要单独编译，单独注册代理存根程序。代理/存根，这个是什么概念？还记得我们在上回书中介绍的吗？当调用者调用进程外或远程组件功能的时候，其实是代理/存根负责数据交换的。关于代理/存根的具体变成和操作，以后再说啦......
　　支持 MFC 除非有特殊的原因，我们写 ATL 程序，最好不要选择该项。你可能会说，如果没有MFC的支持，那CString怎么办呀？告诉你个秘密吧，一般人我都不告诉他，我后半辈子就靠着这个秘密活着了：
　　1、你会STL吗？可以用 STL 中的 string 代替；
　　2、自己写个 MyString 类，嘿嘿；
　　3、悄悄地、秘密地、不要告诉别人（特别是别告诉微软），把 MFC 中的 CString 源码拿过来用；
　　4、使用 CComBSTR 类，至少也能简化我们字符串操作；
　　5、直接用 API 操作字符串，反正我们大家学习 C 语言的时候，都是从这里干起的。（等于没说，呵呵）
　　支持 COM+ 1.0 支持事务处理的 COM+ 功能。COM+ 也许在第 99 回介绍吧。


三、添加 ATL 对象类

　　步骤3.1：菜单"项目\添加类..."（或者用鼠标右键在 项目中弹出菜单"添加\添加类..."）并选择 ATL 简单对象。见图三。


图三、选择建立ATL简单对象

　　除了简单对象(只实现了 IUnknown 接口)，还可以选择“ATL控件”(ActiveX，实现了10多个接口)......可以选择的组件对象类型很多，但本质上，就是让向导帮我们默认加上一些接口。在以后的文章中，陆续介绍吧。

　　步骤3.2：增加自定义类 CFun(接口 IFun) ,见图四。

 
图四、填写名称

　　其实，我们只需要输入简称，其它的项目会自动填写。没什么多说的，只请大家注意一下 ProgID 项，默认的 ProgID 构造方式为“项目名.简称名”。

　　步骤3.3：填写接口属性选项，见图 五。


图五、接口选项

　　线程模型 COM 中的线程，我认为是最讨厌，最复杂的部分。COM 线程和公寓的概念，留待后续介绍。现在吗......大家都选"单元"(Apartment)，它代表什么那？简单地说：当在线程中调用组件函数的时候，这些调用会排队进行。因此，这种模式下，我们可以暂时不用考虑同步的问题。(注1)
　　接口。双重(Dual)，这个非常 非常重要，非常非常常用，但我们今天不讲(注2)。切记！切记！我们的这第一个 COM 程序中，一定要选择“自定义”！！！！（如果你选错了，请删除全部内容，重新来过。）
　　聚合 我们写的组件，将来是否允许被别人聚合(注3)使用。“只能创建为聚合”，有点类似 C++ 中的纯虚类，你要是总工程师，只负责设计但不亲自写代码的话，才选择它。
　　ISupportErrorInfo 是否支持丰富信息的错误处理接口。以后就讲。
　　连接点 是否支持连接点接口（事件、回调）。以后就讲。
　　IObjectWithSite 是否支持IE的调用


四、添加接口函数


图六、调出增加接口方法的菜单


图七、增加接口函数 Add

　　请按照图示的方法，增加Add()函数，增加Cat()函数 。[in]表示参数方向是输入；[out]表示参数方向是输出；[out,retval]表示参数方向是输出，同时可以作为函数运算结果的返回值。一个函数中，可以有多个[in]、[out]，但[retval]只能有一个，并且要和[out]组合后在最后一个位置。(注4)


图八、接口函数定义完成后的图示

　　我们都知道，要想改变 C++ 中的类函数，需要修改两个地方：一是头文件(.h)中类的函数声明，二是函数体(.cpp)文件的实现处。而我们现在用 ATL 写组件程序，则还要修改一个地方，就是接口定义(IDL)文件。别着急 IDL 下次就要讨论啦。


五、实现接口函数

　　鼠标双点图八中CFun\基项和接口\Add(...)就可以开始输入函数实现了：

STDMETHODIMP CFun::Add(long n1, long n2, long *pVal)
{
	*pVal = n1 + n2;

	return S_OK;
}

STDMETHODIMP CFun::Cat(BSTR s1, BSTR s2, BSTR *pVal)
{
	int nLen1 = ::SysStringLen( s1 );	// s1 的字符长度
	int nLen2 = ::SysStringLen( s2 );	// s2 的字符长度

	*pVal = ::SysAllocStringLen( s1, nLen1 + nLen2 );// 构造新的 BSTR 同时把 s1 先保存进去
	if( nLen2 )
	{
		::memcpy( *pVal + nLen1, s2, nLen2 * sizeof(WCHAR) );	// 然后把 s2 再连接进去
//		wcscat( *pVal, s2 );
	}

	return S_OK;
}

STDMETHODIMP CFun::Cat(BSTR s1, BSTR s2, BSTR *pVal)
{
	CComBSTR sResult( s1 );
	sResult.AppendBSTR( s2 );

	*pVal = sResult.Copy();
//	*pVal = sResult.Detach();

	return S_OK;
}

二、建立 ATL 工程
　　步骤2.1：建立一个工作区(WorkSpace)。
　　步骤2.2：在工作区中，建立一个 ATL 工程(Project)。示例程序叫 Simple1，并选择DLL方式，见图一。


图一、建立 ATL DLL 工程

　　Dynamic Link Library(DLL) 表示建立一个 DLL 的组件程序。
　　Executable(EXE) 表示建立一个 EXE 的组件程序。
　　Service(EXE) 表示建立一个服务程序，系统启动后就会加载并执行的程序。
　　Allow merging of proxy/stub code 选择该项表示把“代理/存根”代码合并到组件程序中，否则需要单独编译，单独注册代理存根程序。代理/存根，这个是什么概念？还记得我们在上回书中介绍的吗？当调用者调用进程外或远程组件功能的时候，其实是代理/存根负责数据交换的。关于代理/存根的具体变成和操作，以后再说啦......
　　Support MFC 除非有特殊的原因，我们写 ATL 程序，最好不要选择该项。你可能会说，如果没有MFC的支持，那CString怎么办呀？告诉你个秘密吧，一般人我都不告诉他，我后半辈子就靠着这个秘密活着了：
　　1、你会STL吗？可以用 STL 中的 string 代替；
　　2、自己写个 MyString 类，嘿嘿；
　　3、悄悄地、秘密地、不要告诉别人（特别是别告诉微软），把 MFC 中的 CString 源码拿过来用；
　　4、使用 CComBSTR 类，至少也能简化我们字符串操作；
　　5、直接用 API 操作字符串，反正我们大家学习 C 语言的时候，都是从这里干起的。（等于没说，呵呵）
　　Support MTS 支持事务处理，也就是是否支持 COM+ 功能。COM+ 也许在第 99 回介绍吧。


三、增加 ATL 对象类

　　步骤3.1：菜单 Insert\New ATL Object...（或者用鼠标右键在 ClassView 卡片中弹出菜单）并选择Object 分类，选中 Simple Object 项目。见图二。


图二、选择建立简单COM对象

　　Category Object 普通组件。其中可以选择的组件对象类型很多，但本质上，就是让向导帮我们默认加上一些接口。比如我们选 "Simple Object"，则向导给我们的组件加上 IUnknown 接口；我们选 "Internet Explorer Object"，则向导除了加上 IUnknown 接口外，再增加一个给 IE 所使用的 IObjectWithSite 接口。当然了，我们完全可以手工增加任何接口。
　　Category Controls ActiveX 控件。其中可以选择的 ActiveX 类型也很多。我们在后续的专门介绍 ActiveX 编程中再讨论。
　　Category Miscellaneous 辅助杂类组件。
　　Categroy Data Access 数据库类组件(我最讨厌数据库编程了，所以我也不会)。

　　步骤3.2：增加自定义类 CFun(接口 IFun) ,见图三。


图三、输入类中的各项名称
　　 其实，我们只需要输入短名(Short Name)，其它的项目会自动填写。没什么多说的，只请大家注意一下 ProgID 项，默认的 ProgID 构造方式为“工程名.短名”。

　　 步骤3.3：填写接口属性，见图四。

图四、接口属性

　　Threading Model 选择组件支持的线程模型。COM 中的线程，我认为是最讨厌，最复杂的部分。COM 线程和公寓的概念，留待后续介绍。现在吗......大家都选 Apartment，它代表什么那？简单地说：当在线程中调用组件函数的时候，这些调用会排队进行。因此，这种模式下，我们可以暂时不用考虑同步的问题。(注1)
　　 Interface 接口基本类型。Dual 表示支持双接口(注2)，这个非常 非常重要，非常非常常用，但我们今天不讲。Custom 表示自定义借口。切记！切记！我们的这第一个 COM 程序中，一定要选择它！！！！（如果你选错了，请删除全部内容，重新来过。）
　　 Aggregation 我们写的组件，将来是否允许被别人聚合(注3)使用。Only 表示必须被聚合才能使用，有点类似 C++ 中的纯虚类，你要是总工程师，只负责设计但不亲自写代码的话，才选择它。
　　Support ISupportErrorInfo 是否支持丰富信息的错误处理接口。以后就讲。
　　Support Connection Points 是否支持连接点接口（事件、回调）。以后就讲。
　　Free Threaded Marshaler 以后也不讲，就算打死你，我也不说！(注4)


四、添加接口函数


图五、调出增加接口方法的菜单


图六、增加接口函数 Add


图七、增加接口函数 Cat

　　请严格按照图六的方式，增加Add()函数；由于图七中增加Cat()函数的参数比较长，我没有适当的输入空格，请大家自己输入的时候注意一下。[in]表示参数方向是输入；[out]表示参数方向是输出；[out,retval]表示参数方向是输出，同时可以作为函数运算结果的返回值。一个函数中，可以有多个[in]、[out]，但[retval]只能有一个，并且要和[out]组合后在最后一个位置。(注5)

图八、接口函数定义完成后的图示
　　我们都知道，要想改变 C++ 中的类函数，需要修改两个地方：一是头文件(.h)中类的函数声明，二是函数体(.cpp)文件的实现处。而我们现在用 ATL 写组件程序，则还要修改一个地方，就是接口定义(IDL)文件。别着急 IDL 下次就要讨论啦。
　　由于 vc6.0 的BUG，导致大家在增加完接口和接口函数后，可能不会向上图（图八）所表现的样式。解决方法：
　

五、实现接口函数

　　鼠标双点图八中CFun\IFun\Add(...)就可以开始输入函数实现了：

STDMETHODIMP CFun::Add(long n1, long n2, long *pVal)
{
	*pVal = n1 + n2;

	return S_OK;
}

STDMETHODIMP CFun::Cat(BSTR s1, BSTR s2, BSTR *pVal)
{
	int nLen1 = ::SysStringLen( s1 );	// s1 的字符长度
	int nLen2 = ::SysStringLen( s2 );	// s2 的字符长度

	*pVal = ::SysAllocStringLen( s1, nLen1 + nLen2 );	// 构造新的 BSTR 同时把 s1 先保存进去
	if( nLen2 )
	{
		::memcpy( *pVal + nLen1, s2, nLen2 * sizeof(WCHAR) );	// 然后把 s2 再连接进去
//		wcscat( *pVal, s2 );
	}

	return S_OK;
}

STDMETHODIMP CFun::Cat(BSTR s1, BSTR s2, BSTR *pVal)
{
	CComBSTR sResult( s1 );
	sResult.AppendBSTR( s2 );

	*pVal = sResult.Copy();
//	*pVal = sResult.Detach();

	return S_OK;
}