#include <ole2.h> // OLE2 Definitions

// AutoWrap() - Automation helper function...
HRESULT AutoWrap(int autoType, VARIANT *pvResult, IDispatch *pDisp, LPOLESTR ptName, int cArgs...) {
    // Begin variable-argument list...
    va_list marker;
    va_start(marker, cArgs);

    if(!pDisp) {
        MessageBox(NULL, "NULL IDispatch passed to AutoWrap()", "Error", 0x10010);
        _exit(0);
    }

    // Variables used...
    DISPPARAMS dp = { NULL, NULL, 0, 0 };
    DISPID dispidNamed = DISPID_PROPERTYPUT;
    DISPID dispID;
    HRESULT hr;
    char buf[200];
    char szName[200];

    
    // Convert down to ANSI
    WideCharToMultiByte(CP_ACP, 0, ptName, -1, szName, 256, NULL, NULL);
    
    // Get DISPID for name passed...
    hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT, &dispID);
    if(FAILED(hr)) {
        sprintf(buf, "IDispatch::GetIDsOfNames(\"%s\") failed w/err 0x%08lx", szName, hr);
        MessageBox(NULL, buf, "AutoWrap()", 0x10010);
        _exit(0);
        return hr;
    }
    
    // Allocate memory for arguments...
    VARIANT *pArgs = new VARIANT[cArgs+1];
    // Extract arguments...
    for(int i=0; i<cArgs; i++) {
        pArgs[i] = va_arg(marker, VARIANT);
    }
    
    // Build DISPPARAMS
    dp.cArgs = cArgs;
    dp.rgvarg = pArgs;
    
    // Handle special-case for property-puts!
    if(autoType & DISPATCH_PROPERTYPUT) {
        dp.cNamedArgs = 1;
        dp.rgdispidNamedArgs = &dispidNamed;
    }
    
    // Make the call!
    hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_SYSTEM_DEFAULT, autoType, &dp, pvResult, NULL, NULL);
    if(FAILED(hr)) {
        sprintf(buf, "IDispatch::Invoke(\"%s\"=%08lx) failed w/err 0x%08lx", szName, dispID, hr);
        MessageBox(NULL, buf, "AutoWrap()", 0x10010);
        _exit(0);
        return hr;
    }
    // End variable-argument section...
    va_end(marker);
    
    delete [] pArgs;
    
    return hr;
}

   // Initialize COM for this thread...
   CoInitialize(NULL);

   // Get CLSID for our server...
   CLSID clsid;
   HRESULT hr = CLSIDFromProgID(L"Excel.Application", &clsid);

   if(FAILED(hr)) {

      ::MessageBox(NULL, "CLSIDFromProgID() failed", "Error", 0x10010);
      return -1;
   }

   // Start server and get IDispatch...
   IDispatch *pXlApp;
   hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&pXlApp);
   if(FAILED(hr)) {
      ::MessageBox(NULL, "Excel not registered properly", "Error", 0x10010);
      return -2;
   }

   // Make it visible (i.e. app.visible = 1)
   {

      VARIANT x;
      x.vt = VT_I4;
      x.lVal = 1;
      AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlApp, L"Visible", 1, x);
   }

   // Get Workbooks collection
   IDispatch *pXlBooks;
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"Workbooks", 0);
      pXlBooks = result.pdispVal;
   }

   // Call Workbooks.Add() to get a new workbook...
   IDispatch *pXlBook;
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlBooks, L"Add", 0);
      pXlBook = result.pdispVal;
   }

   // Create a 15x15 safearray of variants...
   VARIANT arr;
   arr.vt = VT_ARRAY | VT_VARIANT;
   {
      SAFEARRAYBOUND sab[2];
      sab[0].lLbound = 1; sab[0].cElements = 15;
      sab[1].lLbound = 1; sab[1].cElements = 15;
      arr.parray = SafeArrayCreate(VT_VARIANT, 2, sab);
   }

   // Fill safearray with some values...
   for(int i=1; i<=15; i++) {
      for(int j=1; j<=15; j++) {
         // Create entry value for (i,j)
         VARIANT tmp;
         tmp.vt = VT_I4;
         tmp.lVal = i*j;
         // Add to safearray...
         long indices[] = {i,j};
         SafeArrayPutElement(arr.parray, indices, (void *)&tmp);
      }
   }

   // Get ActiveSheet object
   IDispatch *pXlSheet;
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"ActiveSheet", 0);
      pXlSheet = result.pdispVal;
   }

   // Get Range object for the Range A1:O15...
   IDispatch *pXlRange;
   {
      VARIANT parm;
      parm.vt = VT_BSTR;
      parm.bstrVal = ::SysAllocString(L"A1:O15");

      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Range", 1, parm);
      VariantClear(&parm);

      pXlRange = result.pdispVal;
   }

   // Set range with our safearray...
   AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlRange, L"Value", 1, arr);

   // Wait for user...
   ::MessageBox(NULL, "All done.", "Notice", 0x10000);

   // Set .Saved property of workbook to TRUE so we aren't prompted
   // to save when we tell Excel to quit...
   {
      VARIANT x;
      x.vt = VT_I4;
      x.lVal = 1;
      AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlBook, L"Saved", 1, x);
   }

   // Tell Excel to quit (i.e. App.Quit)
   AutoWrap(DISPATCH_METHOD, NULL, pXlApp, L"Quit", 0);

   // Release references...
   pXlRange->Release();
   pXlSheet->Release();
   pXlBook->Release();
   pXlBooks->Release();
   pXlApp->Release();
   VariantClear(&arr);

   // Uninitialize COM for this thread...
   CoUninitialize();
			

    VARIANT parm[3];
    parm[0].vt = VT_I4; parm[0].lVal = 1;
    parm[1].vt = VT_I4; parm[1].lVal = 2;
    parm[2].vt = VT_I4; parm[2].lVal = 3;
    AutoWrap(DISPATCH_METHOD, NULL, pDisp, L"call", 3, parm[2], parm[1], parm[0]);

BOOL CMyApp::InitInstance() {
     // ...
     AfxOleInit();
     COleMessageFilter * pFilter = AfxOleGetMessageFilter();
     pFilter->SetMessagePendingDelay(5000);
     // ...
}

에러정보 리턴

l       자동화 객체에서는 IErrorInfo 객체를 생성하여 여기에 발생한 에러에 대한 자세한 정보를 제공

l       자동화 객체는 ISupportErrorInfo 인터페이스를 지원해야 함

에러정보 리턴

    에러 정보를 반환하는 방법은 아래와 같다.

l       CreateErrorInfo 와 SetErrorInfo 함수 이용

l       CComCoClass::Error 함수 이용

l       AtlReportError 함수 이용

에러 정보 받기

l       IDispatch::Invoke의 EXCEPTINFO 인자 사용

l       직접 에러 정보 객체를 사용

1.       에러 발생시 ISupportErrorInfo 인터페이스를 구하여 InterfaceSupportsErrorInfo 함수를 호출 -> IErrorInfo를 지원하는지 여부 확인

2. GetErrorInfo를 호출하여 IErrorInfo 인터페이스를 구한 후 IErrorInfo 인터페이스의 메서드를 호출하여 에러정보를 추출

GetSource, GetDescription, GetGUID, GetHelpFile, GetHelpContext 등 이용

출처 : SDS 멀티 캠퍼스 COM & ATL 과정 강좌

단계별 예제 - DLL 및 형식 라이브러리 만들기

1. Visual C++ 5.0을 열고 파일|새로 만들기를 선택합니다. 프로젝트 탭에서 "Win32 동적 연결 라이브러리"를 선택하고 프로젝트 이름을 "TLBSamp"로 지정합니다.
2. 파일|새로 만들기를 다시 선택합니다. 파일 탭에서 "C++ 소스 파일"을 선택하고 파일 이름을 "TLBSamp.c"로 지정한 다음 확인을 누릅니다.
3. 2단계를 다시 반복하고 이번에는 파일 형식으로 "텍스트 파일"을 선택합니다. 파일 이름을 각각 "TLBSamp.def"와 "TLBSamp.odl"로 지정합니다.
4. 그런 다음 TLBSamp.c에 다음 코드를 추가합니다.
   

    
   #include <windows.h>
    
   // MyDll_ReverseString -- Reverses the characters of a given string
   void __stdcall MyDll_ReverseString(LPSTR lpString)
   {
       _strrev(lpString);
   }
    
   // MyDLL_Rotate -- Returns bit rotation of 32-bit integer value
   int __stdcall MyDll_Rotate(int nVal, int nDirect, short iNumBits)
   {
       int nRet = 0;
    
       if((iNumBits < 1) || (iNumBits > 31))
           return nRet;
    
       switch(nDirect)
       {
       case 0:
           // Rotate nVal left by iNumBits
           nRet = (((nVal) << (iNumBits)) |
               ((nVal) >> (32-(iNumBits))));
           break;
       case 1:
           // Rotate nVal right by iNumBits
           nRet = (((nVal) >> (iNumBits)) |
               ((nVal) << (32-(iNumBits))));
           break;
       }
    
       return nRet;
   }
   
   
   						

5. 함수를 내보낼 수 있게 하려면 TLBSamp.def에 다음 코드를 추가합니다.
   

         LIBRARY TLBSamp
         DESCRIPTION 'Microsoft KB Sample DLL'
         EXPORTS
           MyDll_ReverseString
           MyDll_Rotate
   
   						

6. TLBSamp.odl에 다음 코드를 추가하여 형식 라이브러리에서 함수를 선언합니다.
   

         
    
   // This is the type library for TLBSamp.dll
   [
       // Use GUIDGEN.EXE to create the UUID that uniquely identifies
       // this library on the user's system. NOTE: This must be done!!
       uuid(F1B9E420-F306-11d1-996A-92FF02C40D32),
       // This helpstring defines how the library will appear in the
       // References dialog of VB.
       helpstring("KB Sample: Make your C DLL More Accessible"),
       // Assume standard English locale.
       lcid(0x0409),
       // Assign a version number to keep track of changes.
       version(1.0)
   ]
   library TLBSample
   {
    
       // Define an Enumeration to use in one of our functions.
       typedef enum tagRotateDirection
       {
           tlbRotateLeft=0,
           tlbRotateRight=1
       }RotateDirection;
    
       // Now define the module that will "declare" your C functions.
       [
           helpstring("Sample functions exported by TLibSamp.dll"),
           version(1.0),
           // Give the name of your DLL here.
           dllname("TLBSamp.dll")
       ]
       module MyDllFunctions
       {
    
           [
               // Add a description for your function that the developer can
               // read in the VB Object Browser.
               helpstring("Returns the reverse of a given string."),
               // Specify the actual DLL entry point for the function. Notice
               // the entry field is like the Alias keyword in a VB Declare
               // statement -- it allows you to specify a more friendly name
               // for your exported functions.
               entry("MyDll_ReverseString")
           ]
           // The [in], [out], and [in, out] keywords tell the Automation
           // client which direction parameters need to be passed. Some
           // calls can be optimized if a function only needs a parameter
           // to be passed one-way.
           void __stdcall ReverseString([in, out] LPSTR sMyString);
    
           [
               helpstring("Rotates a Long value in the given direction."),
               entry("MyDll_Rotate")
           ]
           // Besides specifying more friendly names, you can specify a more
           // friendly type for a parameter. Notice the Direction parameter
           // has been declared with our enumeration. This gives the VB
           // developer easy access to our constant values.
           int __stdcall BitRotate([in] int Value,
               [in] RotateDirection Direction,
               [in] short Bits);
    
       } // End of Module
   }; // End of Library
   
   
   
   						

7. 빌드 메뉴에서 "모두 다시 빌드"를 선택하여 DLL과 형식 라이브러리를 컴파일합니다. 컴파일이 완료되면 새 DLL(TLBSamp.dll)을 Visual Basic 디렉터리로 복사하여 테스트합니다.

1. 파일|새로 만들기를 선택합니다. 파일 탭에서 "텍스트 파일"을 선택하고 파일 이름을 "TLBSamp.rc"로 지정한 다음 확인을 누릅니다.
2. 텍스트 창이 나타나면 다음 줄을 추가합니다.
   
   1 typelib TLBSamp.tlb
3. 파일을 저장하고 DLL을 다시 컴파일합니다. 컴파일이 완료되면 새 DLL(TLBSamp.dll)을 Visual Basic 디렉터리로 복사하여 테스트하고 이전 파일을 덮어쓸 것인지 묻는 메시지가 나타나면 파일을 덮어씁니다.

단계별 예제 - Visual Basic 테스트 응용 프로그램

1. DLL과 형식 라이브러리를 테스트하려면 Visual Basic 5.0을 열고 표준 프로젝트를 새로 만듭니다. 기본적으로 Form1이 만들어집니다.
2. 프로젝트 메뉴에서 참조를 선택하여 참조 대화 상자를 불러온 다음 찾아보기를 눌러 새 형식 라이브러리(또는 라이브러리를 리소스로 추가한 경우 DLL)를 찾습니다. 새 형식 라이브러리를 찾은 다음 확인을 누릅니다. Visual Basic은 사용자가 라이브러리를 처음 참조할 때 해당 라이브러리를 자동으로 등록합니다. 참조 목록에서 라이브러리("KB 예제: C DLL을 보다 쉽게 사용할 수 있도록 하기)가 선택되어 있는지 확인한 다음 대화 상자를 닫습니다.
3. F2 키를 눌러 개체 브라우저를 불러옵니다. 라이브러리(TLBSamp)가 Visual Basic 프로젝트에 추가되었으며, 이제 함수를 네이티브 Visual Basic 함수처럼 호출할 수 있습니다. 개발자가 BitRotate 함수에 Direction 매개 변수를 입력하면 열거형 목록이 드롭다운됩니다.
4. Form1에 CommandButton을 추가하고 단추의 Click 이벤트에 다음 코드를 추가합니다.
   

         
    
   ' VBScript source code
   Private Sub Command1_Click()
       Dim n1 As Long, n2 As Long, nTmp As Long
       Dim sTest As String, sMsg As String
    
       sTest = "Hello World!"
       n1 = 100
    
       ReverseString sTest
       sMsg = sTest & " | "
       ReverseString sTest
       sMsg = sMsg & sTest & vbCrLf
    
       nTmp = BitRotate(n1, tlbRotateLeft, 2)
       n2 = BitRotate(nTmp, tlbRotateRight, 2)
       sMsg = sMsg & Str$(n1) & " : " & Str$(nTmp) & " : " & Str$(n2)
    
       MsgBox sMsg
   End Sub
   
   
   
   						

5. 이제 F5 키를 눌러 IDE에서 vb5allB 프로젝트를 실행합니다.
   
   참고: 오류 메시지가 나타나면 Visual Basic이 DLL을 찾을 수 없기 때문일 수 있습니다. 테스트 응용 프로그램을 실행하기 전에 Visual Basic 디렉터리나 시스템 경로에 DLL을 복사했는지 확인하십시오

출처 : http://support.microsoft.com/kb/189133

This example shows how to process an XML document and create a derivative XML document from it.

This example works with Visual Studio 2005.

C/C++ Source File (XmlLiteReaderWriter.cpp)

This is the XML source file that the Process (Read and Write) an XML Document Using XmlLite example uses.

XML Source File (books.xml)

CComObjectRootEx::FinalConstruct

객체의 초기화를 수행한다.

클래스 생성자 대신 FinalConstruct에서 초기화를 수행할 시의 장점은 다음과 같다.

l  생성자에서는 상태 코드를 반환할 수 없지만, FinalConstruct 에서는 HRESULT 값을 반환값으로 사용할 수 있다. ATL에서 제공하는 표준 클래스 팩토리가 클래스의 객체를 생성할 때 이 반환값은 상세한 에러 정보를 제공할 수 있도록 COM 클라이언트에게 전파된다.

l  가상 함수 매커니즘에서는 클래스의 생성자에서 순수 가상 함수를 호출할 수 없다. 클래스의 생성자에서 가상 함수를 호출하는 것은 상속 계층에서 생성 되는 시점에 정의되어 있는 함수만을 호출한다. ( 순수 가상 함수에 대한 호출은 링크 에러를 초래한다.

당신의 클래스는 상속 계층에서 최하위 파생 클래스(the most derived class)가 아닐 때 – 어떤 기능을 지원하기 위해 ATL에서 제공된 파생 클래스라고 기대한다. 초기화가 그 클래스(ATL)에서 제공하는 기능을 사용할 좋은 기회이지만 ( 이것은 당신의 클래스 객체가 다른 객체에 집합(aggregate)될 때는 반드시 그러하다 ) , 당신의 클래스 생성자는 최하위 파생 클래스의 기능에 접근할 수 있는 방법이 없다. 당신 클래스의 생성 코드는 최하위 파생 클래스가 완전히 생성되기 전에 실행된다.

그러나, FinalConstruct 는 최하위 파생 클래스가 완전히 생성된 후에 즉시 호출되기 때문에 가상함수를 호출할 수 있고 ATL에서 제공하는 참조-카운트 구현을 사용할 수 있다.

예제

일반적으로 모든 집합된 객체 (aggregated object)를 생성하기 위해서는 CComObjectRootEx를 상속한 클래스 내에서 이 메소드를 재정의한다.

만일 생성이 실패한다면, 에러를 반환할 수 있다. 또한 생성되는 동안 만일 내부 집합 객체(internal aggregated object)가 참조 카운트를 증가시키고 그러고 나서 참조 카운트를 0으로 감소시킬 때 외부 객체 (outer object)가 삭제되는 것을 보호하기 위해 DECLARE_PROTECT_FINAL_CONSTRUCT 매크로를 사용할 수 있다.

아래는 집합체를 생성하는 일반적인 방법이다.

l  클래스 객체에 IUnknown 포인터를 추가하고 생성자에서 NULL 로 초기화 한다.

l  집합체(aggregate)를 생성하기 위해 FinalConstruct를 재정의 한다.

l  당신이 정의한 IUnknown 포인터를 COM_INTERFACE_ENTRY_AGGREGATE 매크로의 파라미터로 사용한다.

l  IUnknown 포인터를 해제 하기 위해 FinalRelease를 재정한다.

CComObjectRootEx::FinalRelease

객체의 클린업을 수행하기 위해 파생 클래스에서 이 메소드를 재정의 할 수 있다.

기본적으로, CComObjectRootEx::FinalRelease 는 아무것도 하지 않는다.

FinalRelease에서 클린업을 수행하는 것은 클래스의 소멸자에 클린업 코드를 추가하는 것보다 선호된다 왜냐하면 그 객체는 FinalRelease 가 호출되는 시점에도 여전히 완전히 생성되어 있기 때문이다. 이것은 이것은 최하위 파생클래스에서 제공하는 메소드에 대한 안전한 접근을 가능하게 한다. 이것은 삭제되기 전에 모든 집합 객체(any aggregated objects)를 해제하는 경우 특히 중요하다.

참고 : MSDN 2005

IDispatch 인터페이스

Visual Basic 자동화 컨트롤러 애플리케이션 코드에서 어떻게 이들 메서드를 사용하는지 알아 보자.

set obj = CreateObject(“AddBack.AddBack.1”)

à CLSIDFromProgID 함수 호출

“AddBack.AddBack.1” -> CLSID 로 변환

à CoCreateInstance 함수 호출

자동화 객체 인스턴스 생성

IDispatch 인터페이스 포인터를 obj에 저장

obj.Prop = propValue

à GetIDsOfNames 메서드 호출

Prop의 DISPID 값 구함

à Invoke 함수 호출 (DISPID를 매개변수로)

obj.Method

à GetIDsOfNames 메서드 호출

Method 의 DISPID 값 구함

à Invoke 함수 호출 (DISPID를 매개변수로)

자동화 객체

IDispatch 인터페이스를 통하여 메서드나 속성을 노출시키기는 하지만 직접 기능을 노출시키는 것은 아님

à 대신, Invoke 함수를 통하여 자동화 컨트롤러에게 메서드와 속성을 노출시킴

GetIDsOfNames 함수로 구한 DISPID를 매개변수로 Invoke 함수를 호출한다. 이때 Invoke 함수는 switch 문을 사용하여 매개변수로 넘어온 DISPID에 대응되는 case 문 코드 블록을 실행하게 구현할 수도 있다.

디스패치 인터페이스 (dispatch interface, dispinterface)

IDispatch::Invoke 함수에 의하여 구현되는 함수 포인터 배열을 dispatch interface 또는 dispinterface 라고 한다.

구조를 그림으로 나타내면 다음과 같다.

dispinterface 는 COM 인터페이스가 아니다. 디스패치 인터페이스는 COM 인터페이스와 달리 가상 함수 테이블의 처음 세 개의 요소에 QueryInterface, AddRef, Release 함수 포인터가 저장되지 않는다. 그러나 물론, COM 인터페이스를 사용하여 dispinterface를 구현할 수도 있다.

이중 인터페이스 (Dual Interface)

자동화 객체는 IDispatch 인터페이스 외에도 이와 동일한 역할을 하는 커스텀 인터페이스를 함께 제공함으로써, 일반적인 COM 인터페이스에 접근할 수 있는 언어에서도 효율적으로 서비스를 사용할 수 있게 된다.

이중인터페이스란?

IDispatch::Invoke 함수를 통하여 사용할 수 있는 모든 함수를 인터페이스 테이블 즉, 가상 함수 테이블(vtable)을 통해서도 직접 사용할 수 있게 하도록 구현된다.

이중 인터페이스의 구조를 그림으로 나타내면 다음과 같다.

이중 인터페이스는

l  C++ 프로그램이 가상 함수 테이블을 통하여 직접 함수를 호출함으로써 더욱 빨리 실행함 수 있게 함과 동시에,

l  매크로 언어에서는 IDispatch 인터페이스의 Invoke 함수를 통하여 함수를 호출할 수 있게 하는 효율성을 제공한다.

#import 지시어가 생성하는 .TLI 파일의 메서드 구현 코드는 다음 예와 같이 HRESULT 값을 검사하여 실패한 경우에 _com_issue_error 또는 _com_issue_errorex 함수를 호출한다.

l  _com_issue_error

단순히 HRESULT 값을 매개변수로 취하여 _com_error 데이터형의 예외를 던짐

l  _com_issue_errorex

HRESULT 값과 함께 인터페이스 포인터와 IID를 매개변수로 취하여 해당 인터페이스가 IErrorInfo 인터페이스를 지원하면 IErrorInfo 객체를 구하여 HRESULT와 함께 IErrorInfo 객체 정보를 포함시켜 _com_error 데이터형의 예외를 던짐

예외 처리

_com_ptr_t 스마트 포인터 클래스를 통하여 COM 객체를 사용할 때 발생하는 에러를 처리할 수 있다.

_com_error 예외 타입 클래스 멤버

l  ErrorMessage : 에러를 설명하는 const TCHAR * 리턴

l  Error : HRESULT 값, 즉 에러 코드값 리턴

l  Source : IErrorInfo::GetSource 멤버 함수의 호출 결과(_bstr_t) 즉, 에러 소스 리턴

l  Description : IErrorInfo::GetDescription 멤버 함수의 호출 결과(_bstr_t) 리턴

만일 IErrorInfo가 저장되어 있지 않은 경우 빈 _bstr_t를 리턴하며, IErrorInfo 멤버 함수를 호출하는 동안 발생한 실패는 무시된다.

예외의 발생

다음 예제와 같이 _error_issue_error 함수를 사용

참고 : 전병선의 Component Development with Visual C++ & ATL

_com_ptr_t 스마트 포인터 클래스

           스마트 포인터 기능을 갖고 있는 템플릿 클래스

COMIP.H 헤더 파일에 정의

_COM_SMARTPTR_TYPEDEF 매크로를 이용하여 Ptr이 붙는 _com_ptr_t 클래스를 정의

위의 매크로는 다음과 같이 확장 된다.

_com_ptr_t 스마트 포인턴 클래스를 사용하여 COM 객체의 인스턴스 생성 방법

1.     생성자 이용

2.     CreateInstance 함수 이용

명시적으로 인터페이스 포인터를 해제하고자 할 경우 다음과 같이 할 수 있다.

 참고 : 전병선의 Component Development with Visual C++ & ATL

__declspec(uuid()) 와 __uuidof()

__declspec의 uuid 확장 속성을 사용하여 다음과 같이 COM 객체나 인터페이스에 GUID를 지정할 수 있게 한다.

이와 같이 __declspec(uuid())를 사용하여 지정된 GUID 값을 꺼내오기 위해 __uuidof를 사용할 수 있다.

__declspec(property)

클래스의 ‘비정적 가상 데이터 멤버(non static virtual data member)’에 사용할 수 있다. 이 속성이 지정되고 이 변수에 포인터 멤버 선택 연산자(->)를 사용하여 참조할 때 컴파일러는 이들에 대하여 대응되는 함수 호출로 변경한다.

위의 __declspec(property) 확장 속성은 포인터 멤버 선택 연산자(->)와 함께 name 식별자가 rvalue로 사용될 때 get 함수로 지정된 Getname 함수를 호출하고, name 식별자가 lvalue로 사용될 때 put 함수로 지정된 Putname 함수를 호출하게 한다.

따라서, 다음과 같이 name 데이터 멤버에서 값을 읽는 코드가 작성될 때,

Visual C++ 컴파일러는 다음과 같이 get 함수로 지정된 Getname 함수를 호출한다.

 
참고 : 전병선의 Component Development with Visual C++ & ATL

클라이언트 애플리케이션에서 COM 객체의 인스턴스를 생성하기 위해 CoCreateInstance() 함수를 호출하면 내부적으로는 CoGetClassObject() 함수를 호출한다. 이때 CoGetClassObject() 함수는 레지스트리에서 해당 COM 객체의 정보를 찾아 CoLoadLibrary() API 함수를 호출함으로써 해당 COM 객체를 구현한 인-프로세스 서버 DLL을 메모리에 로드한다. 다음에 CoGetClassObject() 함수는 메모리에 로드한 인-프로세스 서버 DLL로부터 DllGetClassObject 익스포트 함수를 호출하고 생성하고자 하는 COM 객체의 CLSID를 넘겨준다.

이때 인-프로세스 서버 DLL에 구현된 DllGetClassObject() 함수에서는 인수로 넘어온 CLSID 값에 대응되는 클래스 팩토리 COM 객체의 인스턴스를 생성하고 클래스 팩토리 COM 객체의 IClassFactory 인터페이스 포인터를 구하여 CoGetClassObject() 함수에 리턴해 준다. 다시 CoGetClassObject() 함수는 CoCreateInstance() 함수에게 IClassFactory 인터페이스 포인터를 넘겨주게 되고 CoCreateInstane() 함수는 이 인터페이스 포인터를 통해 IClassFactory 인터페이스의 CreateInstance() 메서드를 호출함으로써 COM 객체의 인스턴스를 생성하게 된다.

결국 클라이언트 애플리케이션에서 COM 객체의 인스턴스를 생성하기 위해 CoCreateInstance() 함수를 호출하면 COM 라이브러리는 인-프로세스 서버 COM 컴포넌트 DLL을 메모리에 로드한 후 이 DLL에 DllGetClassObject() 익스포트 함수를 호출하는 것이다.

참고 : 전병선의 Component Development with Visual C++ & ATL

Dll이 처음 메모리에 로드되면 DllMain()이라고 하는 진입점(entry-point) 함수가 호출된다.

DllMain() 함수는 다음과 같은 구조를 갖는다.

흥미로운 것은 DLL을 로드한 프로세스가 새로운 스레드를 생성할 때도 DllMain() 함수가 호출된다. 이 경우에는 dwReason 인수에 DLL_THREAD_ATTACH 값이 전달된다. 마찬가지로 DLL을 로드한 프로세스가 생성된 스레드를 소멸시킬 때도 DllMain() 함수가 호출되면 이 경우에는 DLL_THREAD_DETACH 값이 dwReason 인수에 전달된다.

참고 : 전병선의 Component Development with Visual C++ & ATL

애트리뷰트 매커니즘

컴파일러가 애트리뷰트를 만나면,

1.     파싱을 하고 구문 분석

2.     애트리뷰트 공급자(attribute provider) 호출

3.     컴파일 시에 코드를 삽입하거나 수정

/Fx 옵션으로 소스 코드를 컴파일함으로써 애트리뷰트에 대한 애트리뷰트 공급자가 생성한 코드를 볼 수 있다.

ATL에서 Visual C++의 _com_ptr_t 스마트 포인터 템플릿 클래스에 해당되는 클래스로 CComPtr과 CComQIPtr 템플릿 클래스를 제공.

l  자동적으로 AddRef와 Release 호출

l  인터페이스 포인터 변수와 이들 클래스의 인스턴스를 구별없이 사용

l  CComQIPtr은 추가로 QueryInterface를 통하여 자동적으로 인터페이스를 질의하는 기능 제공

l  _com_ptr_t와는 달리 COM 객체의 인스턴스를 생성하는 일은 하지 못함

1.    CComPtr

다음의 생성자를 가짐

사용 예

2.    CComQIPtr

CComQIPtr 클래스는 템플릿 매개변수로 인터페이스에 대한 GUID 포인터를 추가로 받아들이는 것을 제외하고는 CComPtr 클래스와 유사하다.

CComQIPtr 클래스는 IUnknown 인터페이스 포인터를 매개변수로 받아들이는 생성자와 대입 연산자 멤버 함수를 제공함으로써, 다른 인터페이스 포인터나 다른 인터페이스 포인터를 캡슐화하는 CComPtr 또는 CComQIPtr 클래스 객체가 매개 변수로 넘어올 때 QueryInterface 메서드를 호출해준다.

CComQIPtr 클래스의 사용 예

CComPtr 템플릿 클래스는 이제 필요없게 되는 걸까?

n  ATL 버전과의 호환성 때문이라도 남아 있어야 한다

n  CComQIPtr 템플릿 클래스가 IUnknown 인터페이스는 수용하지 않는다

위 코드에 대해서 컴파일러는 컴파일 에러 메시지를 보여주게 된다. 따라서, IUnknown 인터페이스를 수용하는 템플릿 클래스 객체를 사용하기 위해서는 다음과 같이 CComPtr 템플릿 클래스를 사용해야 한다.

출처 : 전병선의 Component Development with Visual C++ & ATL

void func( LPSTR lpsz )
{
   USES_CONVERSION;
   ...
   LPWSTR x = A2W(lpsz)
   // Do something with x
   ...
}

 
참고로 변환을 하드 코딩하는 API로 WideCharToMultiByte 와 MultiByteToWideChar 라는 변환 함수를 제공한다.

참고 : http://msdn.microsoft.com/ko-kr/library/87zae4a3(VS.80).aspx