com::ptr 클래스com::ptr Class

CLR 클래스의 멤버로 사용할 수 있는 COM 개체에 대한 래퍼입니다.A wrapper for a COM object that can be used as a member of a CLR class. 이 래퍼는 또한 COM 개체의 수명 주기 관리를 자동화하여 소멸자가 호출될 때 개체에서 모든 소유 참조를 해제합니다.The wrapper also automates lifetime management of the COM object, releasing all owned references on the object when its destructor is called. CComPtr 클래스와 유사 합니다.Analogous to CComPtr class.

구문Syntax

template<class _interface_type>
ref class ptr;

매개 변수Parameters

_interface_type_interface_type
COM 인터페이스.COM interface.

설명Remarks

또한 com::ptr은 로컬 함수 변수로 사용하여 여러 COM 작업을 간소화하고 수명 주기 관리를 자동화할 수 있습니다.A com::ptr can also be used as a local function variable to simplify various COM tasks and to automate lifetime management.

com::ptr 함수 매개 변수로 직접 사용할 수 없습니다. 대신 추적 참조 연산자 또는 개체 연산자 (^)에 대 한 핸들 을 사용 하십시오.A com::ptr can't be used directly as a function parameter; use a Tracking reference operator or a Handle to object operator (^) instead.

com::ptr 함수에서 직접 반환 될 수 없습니다. 대신 핸들을 사용 하십시오.A com::ptr can't be directly returned from a function; use a handle instead.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. 클래스의 공용 메서드를 호출하면 포함된 IXMLDOMDocument 개체가 호출됩니다.Calling the public methods of the class results in calls to the contained IXMLDOMDocument object. 이 샘플은 XML 문서의 인스턴스를 만들고, 여기에 일부 간단한 XML을 채우고, 구문 분석된 문서 트리에서 간소화된 노드 작업을 수행하고 XML을 콘솔에 출력합니다.The sample creates an instance of an XML document, fills it with some simple XML, and does a simplified walk of the nodes in the parsed document tree to print the XML to the console.

// comptr.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   void LoadXml(String^ xml) {
      pin_ptr<const wchar_t> pinnedXml = PtrToStringChars(xml);
      BSTR bstr = NULL;

      try {
         // load some XML into the document
         bstr = ::SysAllocString(pinnedXml);
         if (NULL == bstr) {
            throw gcnew OutOfMemoryException;
         }
         VARIANT_BOOL bIsSuccessful = false;
         // use operator -> to call IXMODOMDocument member function
         Marshal::ThrowExceptionForHR(m_ptrDoc->loadXML(bstr, &bIsSuccessful));
      }
      finally {
         ::SysFreeString(bstr);
      }
   }

   // simplified function to write just the first xml node to the console
   void WriteXml() {
      IXMLDOMNode* pNode = NULL;

      try {
         // the first child of the document is the first real xml node
         Marshal::ThrowExceptionForHR(m_ptrDoc->get_firstChild(&pNode));
         if (NULL != pNode) {
            WriteNode(pNode);
         }
      }
      finally {
         if (NULL != pNode) {
            pNode->Release();
         }
      }
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   // simplified function that only writes the node
   void WriteNode(IXMLDOMNode* pNode) {
      BSTR bstr = NULL;

      try {
         // write out the name and text properties
         Marshal::ThrowExceptionForHR(pNode->get_nodeName(&bstr));
         String^ strName = gcnew String(bstr);
         Console::Write("<{0}>", strName);
         ::SysFreeString(bstr);
         bstr = NULL;

         Marshal::ThrowExceptionForHR(pNode->get_text(&bstr));
         Console::Write(gcnew String(bstr));
         ::SysFreeString(bstr);
         bstr = NULL;

         Console::WriteLine("</{0}>", strName);
      }
      finally {
         ::SysFreeString(bstr);
      }
   }

   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// use the ref class to handle an XML DOM Document object
int main() {
   try {
      // create the class from a progid string
      XmlDocument doc("Msxml2.DOMDocument.3.0");

      // stream some xml into the document
      doc.LoadXml("<word>persnickety</word>");

      // write the document to the console
      doc.WriteXml();
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
}
<word>persnickety</word>

멤버Members

Public 생성자Public constructors

NameName 설명Description
ptr::p trptr::ptr COM 개체를 래핑하는을 생성 com::ptr 합니다.Constructs a com::ptr to wrap a COM object.
ptr::~ptrptr::~ptr Destructs a com::ptr .Destructs a com::ptr.

public 메서드Public methods

NameName 설명Description
ptr::Attachptr::Attach COM 개체를에 연결 com::ptr 합니다.Attaches a COM object to a com::ptr.
ptr::CreateInstanceptr::CreateInstance 내에서 COM 개체의 인스턴스를 만듭니다 com::ptr .Creates an instance of a COM object within a com::ptr.
ptr::Detachptr::Detach COM 개체의 소유권을 부여 하 여 개체에 대 한 포인터를 반환 합니다.Gives up ownership of the COM object, returning a pointer to the object.
ptr::GetInterfaceptr::GetInterface 내에서 COM 개체의 인스턴스를 만듭니다 com::ptr .Creates an instance of a COM object within a com::ptr.
ptr::QueryInterfaceptr::QueryInterface 소유 된 COM 개체를 쿼리하여 인터페이스에 연결 하 고 그 결과를 다른에 연결 com::ptr 합니다.Queries the owned COM object for an interface and attaches the result to another com::ptr.
ptr::Releaseptr::Release COM 개체에서 소유 된 모든 참조를 해제 합니다.Releases all owned references on the COM object.

Public 연산자Public operators

NameName 설명Description
ptr:: operator->ptr::operator-> 소유 하는 COM 개체에서 메서드를 호출 하는 데 사용 되는 멤버 액세스 연산자입니다.Member access operator, used to call methods on the owned COM object.
ptr::operator=ptr::operator= COM 개체를에 연결 com::ptr 합니다.Attaches a COM object to a com::ptr.
ptr:: operator   boolptr::operator bool 조건식에 사용 하기 위한 연산자 com::ptr 입니다.Operator for using com::ptr in a conditional expression.
ptr:: operator!ptr::operator! 소유 하는 COM 개체가 잘못 되었는지 여부를 확인 하는 연산자입니다.Operator to determine if the owned COM object is invalid.

요구 사항Requirements

헤더 파일 <msclr\com\ptr.h>Header file <msclr\com\ptr.h>

네임 스페이스 msclr:: comNamespace msclr::com

ptr::p trptr::ptr

소유 하는 COM 개체에 대 한 포인터를 반환 합니다.Returns a pointer to the owned COM object.

ptr();
ptr(
   _interface_type * p
);

매개 변수Parameters

PP
COM 인터페이스 포인터.A COM interface pointer.

설명Remarks

인수가 없는 생성자는 nullptr 내부 개체 핸들에를 할당 합니다.The no-argument constructor assigns nullptr to the underlying object handle. 이후에를 호출 com::ptr 하면 내부 개체의 유효성이 검사 되 고 개체가 만들어지거나 연결 될 때까지 자동으로 실패 합니다.Future calls to the com::ptr will validate the internal object and silently fail until an object is created or attached.

단일 인수 생성자는 COM 개체에 대 한 참조를 추가 하지만 호출자의 참조를 해제 하지 않으므로 호출자가 Release com 개체에 대해를 호출 하 여 컨트롤을 실제로 지정 해야 합니다.The one-argument constructor adds a reference to the COM object but doesn't release the caller's reference, so the caller must call Release on the COM object to truly give up control. com::ptr의 소멸자가 호출 되 면 해당 참조는 COM 개체에서 자동으로 해제 됩니다.When the com::ptr's destructor is called it will automatically release its references on the COM object.

NULL이 생성자에 전달 하는 것은 인수가 없는 버전을 호출 하는 것과 같습니다.Passing NULL to this constructor is the same as calling the no-argument version.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. 이 예제에서는 두 가지 버전의 생성자를 모두 사용 하는 방법을 보여 줍니다.It demonstrates usage of both versions of the constructor.

// comptr_ptr.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   // construct the internal com::ptr with a COM object
   XmlDocument(IXMLDOMDocument* pDoc) : m_ptrDoc(pDoc) {}

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// use the ref class to handle an XML DOM Document object
int main() {
   IXMLDOMDocument* pDoc = NULL;

   try {
      // create an XML DOM document object
      Marshal::ThrowExceptionForHR(CoCreateInstance(CLSID_DOMDocument30, NULL,
         CLSCTX_ALL, IID_IXMLDOMDocument, (void**)&pDoc));
      // construct the ref class with the COM object
      XmlDocument doc1(pDoc);

      // or create the class from a progid string
      XmlDocument doc2("Msxml2.DOMDocument.3.0");
   }
   // doc1 and doc2 destructors are called when they go out of scope
   // and the internal com::ptr releases its reference to the COM object
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
   finally {
      if (NULL != pDoc) {
         pDoc->Release();
      }
   }
}

ptr:: ~ ptrptr::~ptr

Destructs a com::ptr .Destructs a com::ptr.

~ptr();

설명Remarks

소멸 시는 소유 하 고 있는 com::ptr 모든 참조를 COM 개체에 해제 합니다.On destruction, the com::ptr releases all references it owns to its COM object. COM 개체에 대 한 다른 참조가 없다는 가정 하에 COM 개체가 삭제 되 고 해당 메모리가 확보 됩니다.Assuming that there are no other references held to the COM object, the COM object will be deleted and its memory freed.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. 함수에서 mainXmlDocument 개체의 소멸자가 블록 범위를 벗어날 때 호출 되어 try 기본 소멸자가 호출 되어 com::ptr COM 개체에 대 한 모든 소유 된 참조를 해제 합니다.In the main function, the two XmlDocument objects' destructors will be called when they go out of the scope of the try block, resulting in the underlying com::ptr destructor being called, releasing all owned references to the COM object.

// comptr_dtor.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   // construct the internal com::ptr with a COM object
   XmlDocument(IXMLDOMDocument* pDoc) : m_ptrDoc(pDoc) {}

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// use the ref class to handle an XML DOM Document object
int main() {
   IXMLDOMDocument* pDoc = NULL;

   try {
      // create an XML DOM document object
      Marshal::ThrowExceptionForHR(CoCreateInstance(CLSID_DOMDocument30, NULL,
         CLSCTX_ALL, IID_IXMLDOMDocument, (void**)&pDoc));
      // construct the ref class with the COM object
      XmlDocument doc1(pDoc);

      // or create the class from a progid string
      XmlDocument doc2("Msxml2.DOMDocument.3.0");
   }
   // doc1 and doc2 destructors are called when they go out of scope
   // and the internal com::ptr releases its reference to the COM object
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
   finally {
      if (NULL != pDoc) {
         pDoc->Release();
      }
   }
}

ptr:: Attachptr::Attach

COM 개체를에 연결 com::ptr 합니다.Attaches a COM object to a com::ptr.

void Attach(
   _interface_type * _right
);

매개 변수Parameters

_right_right
연결할 COM 인터페이스 포인터입니다.The COM interface pointer to attach.

예외Exceptions

com::ptr COM 개체에 대 한 참조를 이미 소유 하 고 있으면이 Attach throw InvalidOperationException 됩니다.If the com::ptr already owns a reference to a COM object, Attach throws InvalidOperationException.

설명Remarks

에 대 한 호출은 Attach COM 개체를 참조 하지만 해당 개체에 대 한 호출자 참조는 해제 하지 않습니다.A call to Attach references the COM object but doesn't release the caller's reference to it.

NULL에를 전달 하면 Attach 작업이 수행 되지 않습니다.Passing NULL to Attach results in no action being taken.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. ReplaceDocument멤버 함수는 먼저 Release 이전에 소유한 개체에 대해를 호출한 다음 Attach 를 호출 하 여 새 문서 개체를 연결 합니다.The ReplaceDocument member function first calls Release on any previously owned object and then calls Attach to attach a new document object.

// comptr_attach.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   // replace currently held COM object with another one
   void ReplaceDocument(IXMLDOMDocument* pDoc) {
      // release current document object
      m_ptrDoc.Release();
      // attach the new document object
      m_ptrDoc.Attach(pDoc);
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// unmanaged function that creates a raw XML DOM Document object
IXMLDOMDocument* CreateDocument() {
   IXMLDOMDocument* pDoc = NULL;
   Marshal::ThrowExceptionForHR(CoCreateInstance(CLSID_DOMDocument30, NULL,
      CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (void**)&pDoc));
   return pDoc;
}

// use the ref class to handle an XML DOM Document object
int main() {
   IXMLDOMDocument* pDoc = NULL;

   try {
      // create the class from a progid string
      XmlDocument doc("Msxml2.DOMDocument.3.0");

      // get another document object from unmanaged function and
      // store it in place of the one held by our ref class
      pDoc = CreateDocument();
      doc.ReplaceDocument(pDoc);
      // no further need for raw object reference
      pDoc->Release();
      pDoc = NULL;
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
   finally {
      if (NULL != pDoc) {
         pDoc->Release();
      }
   }
}

ptr:: CreateInstanceptr::CreateInstance

내에서 COM 개체의 인스턴스를 만듭니다 com::ptr .Creates an instance of a COM object within a com::ptr.

void CreateInstance(
   System::String ^ progid,
   LPUNKNOWN pouter,
   DWORD cls_context
);
void CreateInstance(
   System::String ^ progid,
   LPUNKNOWN pouter
);
void CreateInstance(
   System::String ^ progid
);
void CreateInstance(
   const wchar_t * progid,
   LPUNKNOWN pouter,
   DWORD cls_context
);
void CreateInstance(
   const wchar_t * progid,
   LPUNKNOWN pouter
);
void CreateInstance(
   const wchar_t * progid
);
void CreateInstance(
   REFCLSID rclsid,
   LPUNKNOWN pouter,
   DWORD cls_context
);
void CreateInstance(
   REFCLSID rclsid,
   LPUNKNOWN pouter
);
void CreateInstance(
   REFCLSID rclsid
);

매개 변수Parameters

progidprogid
ProgID 문자열입니다.A ProgID string.

pouterpouter
집계 개체의 IUnknown 인터페이스에 대 한 포인터입니다 (IUnknown 제어).Pointer to the aggregate object's IUnknown interface (the controlling IUnknown). pouter을 지정 하지 않으면 NULL 가 사용 됩니다.If pouter isn't specified, NULL is used.

cls_contextcls_context
새로 만든 개체를 관리 하는 코드가 실행 되는 컨텍스트입니다.Context in which the code that manages the newly created object will run. 값은 열거형에서 가져옵니다 CLSCTX .The values are taken from the CLSCTX enumeration. cls_context을 지정 하지 않으면 CLSCTX_ALL 값이 사용 됩니다.If cls_context isn't specified, the value CLSCTX_ALL is used.

rclsidrclsid
CLSID개체를 만드는 데 사용 되는 데이터 및 코드와 연결 됩니다.CLSID associated with the data and code that will be used to create the object.

예외Exceptions

com::ptr COM 개체에 대 한 참조를 이미 소유 하 고 있으면이 CreateInstance throw InvalidOperationException 됩니다.If the com::ptr already owns a reference to a COM object, CreateInstance throws InvalidOperationException.

이 함수는를 호출 하 CoCreateInstance 고를 사용 하 여 ThrowExceptionForHR 모든 오류 HRESULT 를 적절 한 예외로 변환 합니다.This function calls CoCreateInstance and uses ThrowExceptionForHR to convert any error HRESULT to an appropriate exception.

설명Remarks

CreateInstance를 사용 하 여 CoCreateInstance ProgID 또는 CLSID에서 식별 된 지정 된 개체의 새 인스턴스를 만듭니다.CreateInstance uses CoCreateInstance to create a new instance of the specified object, identified either from a ProgID or a CLSID. com::ptr 새로 만든 개체를 참조 하 고 소멸 될 때 소유 된 모든 참조를 자동으로 해제 합니다.The com::ptr references the newly created object and will automatically release all owned references upon destruction.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. 클래스 생성자는의 두 가지 형태 CreateInstance 를 사용 하 여 ProgID 또는 CLSID와 CLSCTX에서 문서 개체를 만듭니다.The class constructors use two different forms of CreateInstance to create the document object either from a ProgID or from a CLSID plus a CLSCTX.

// comptr_createinstance.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }
   XmlDocument(REFCLSID clsid, DWORD clsctx) {
      m_ptrDoc.CreateInstance(clsid, NULL, clsctx);
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// use the ref class to handle an XML DOM Document object
int main() {
   try {
      // create the class from a progid string
      XmlDocument doc1("Msxml2.DOMDocument.3.0");

      // or from a clsid with specific CLSCTX
      XmlDocument doc2(CLSID_DOMDocument30, CLSCTX_INPROC_SERVER);
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
}

ptr::D etachptr::Detach

COM 개체의 소유권을 부여 하 여 개체에 대 한 포인터를 반환 합니다.Gives up ownership of the COM object, returning a pointer to the object.

_interface_type * Detach();

반환 값Return value

COM 개체에 대 한 포인터입니다.The pointer to the COM object.

소유 하는 개체가 없는 경우 NULL이 반환 됩니다.If no object is owned, NULL is returned.

예외Exceptions

내부적으로 QueryInterface 는 소유 된 COM 개체에서 호출 되 고 오류는에 HRESULT 의해 예외로 변환 됩니다 ThrowExceptionForHR .Internally, QueryInterface is called on the owned COM object and any error HRESULT is converted to an exception by ThrowExceptionForHR.

설명Remarks

Detach는 먼저 호출자를 대신 하 여 COM 개체에 대 한 참조를 추가한 다음에서 소유 하는 모든 참조를 해제 com::ptr 합니다.Detach first adds a reference to the COM object on behalf of the caller and then releases all references owned by the com::ptr. 호출자는 궁극적으로 반환 된 개체를 해제 하 여 제거 해야 합니다.The caller must ultimately release the returned object to destroy it.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. DetachDocument멤버 함수는 Detach 를 호출 하 여 COM 개체의 소유권을 부여 하 고 호출자에 게 포인터를 반환 합니다.The DetachDocument member function calls Detach to give up ownership of the COM object and return a pointer to the caller.

// comptr_detach.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   // detach the COM object and return it
   // this releases the internal reference to the object
   IXMLDOMDocument* DetachDocument() {
      return m_ptrDoc.Detach();
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// unmanaged function that loads XML into a raw XML DOM Document object
HRESULT LoadXml(IXMLDOMDocument* pDoc, BSTR bstrXml) {
   HRESULT hr = S_OK;
   VARIANT_BOOL bSuccess;
   hr = pDoc->loadXML(bstrXml, &bSuccess);
   if (S_OK == hr && !bSuccess) {
      hr = E_FAIL;
   }
   return hr;
}

// use the ref class to handle an XML DOM Document object
int main() {
   IXMLDOMDocument* pDoc = NULL;
   BSTR bstrXml = NULL;

   try {
      // create the class from a progid string
      XmlDocument doc("Msxml2.DOMDocument.3.0");

      bstrXml = ::SysAllocString(L"<word>persnickety</word>");
      if (NULL == bstrXml) {
         throw gcnew OutOfMemoryException("bstrXml");
      }
      // detach the document object from the ref class
      pDoc = doc.DetachDocument();
      // use unmanaged function and raw object to load xml
      Marshal::ThrowExceptionForHR(LoadXml(pDoc, bstrXml));
      // release document object as the ref class no longer owns it
      pDoc->Release();
      pDoc = NULL;
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
   finally {
      if (NULL != pDoc) {
         pDoc->Release();
      }

   }
}

ptr:: GetInterfaceptr::GetInterface

소유 하는 COM 개체에 대 한 포인터를 반환 합니다.Returns a pointer to the owned COM object.

_interface_type * GetInterface();

반환 값Return value

소유 된 COM 개체에 대 한 포인터입니다.A pointer to the owned COM object.

예외Exceptions

내부적으로 QueryInterface 는 소유 된 COM 개체에서 호출 되 고 오류는에 HRESULT 의해 예외로 변환 됩니다 ThrowExceptionForHR .Internally, QueryInterface is called on the owned COM object and any error HRESULT is converted to an exception by ThrowExceptionForHR.

설명Remarks

com::ptr 호출자를 대신 하 여 com 개체에 대 한 참조를 추가 하 고 com 개체에 대 한 참조도 유지 합니다.The com::ptr adds a reference to the COM object on the caller's behalf and also keeps its own reference on the COM object. 호출자는 궁극적으로 반환 된 개체에 대 한 참조를 해제 해야 합니다. 그렇지 않으면 소멸 되지 않습니다.The caller must ultimately release the reference on the returned object or it will never be destroyed.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. GetDocument멤버 함수는를 사용 하 여 GetInterface COM 개체에 대 한 포인터를 반환 합니다.The GetDocument member function uses GetInterface to return a pointer to the COM object.

// comptr_getinterface.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   // add a reference to and return the COM object
   // but keep an internal reference to the object
   IXMLDOMDocument* GetDocument() {
      return m_ptrDoc.GetInterface();
   }

   // simplified function that only writes the first node
   void WriteDocument() {
      IXMLDOMNode* pNode = NULL;
      BSTR bstr = NULL;

      try {
         // use operator -> to call XML Doc member
         Marshal::ThrowExceptionForHR(m_ptrDoc->get_firstChild(&pNode));
         if (NULL != pNode) {
            // write out the xml
            Marshal::ThrowExceptionForHR(pNode->get_nodeName(&bstr));
            String^ strName = gcnew String(bstr);
            Console::Write("<{0}>", strName);
            ::SysFreeString(bstr);
            bstr = NULL;

            Marshal::ThrowExceptionForHR(pNode->get_text(&bstr));
            Console::Write(gcnew String(bstr));
            ::SysFreeString(bstr);
            bstr = NULL;

            Console::WriteLine("</{0}>", strName);
         }
      }
      finally {
         if (NULL != pNode) {
            pNode->Release();
         }
         ::SysFreeString(bstr);
      }
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// unmanaged function that loads XML into a raw XML DOM Document object
HRESULT LoadXml(IXMLDOMDocument* pDoc, BSTR bstrXml) {
   HRESULT hr = S_OK;
   VARIANT_BOOL bSuccess;
   hr = pDoc->loadXML(bstrXml, &bSuccess);
   if (S_OK == hr && !bSuccess) {
      hr = E_FAIL;
   }
   return hr;
}

// use the ref class to handle an XML DOM Document object
int main() {
   IXMLDOMDocument* pDoc = NULL;
   BSTR bstrXml = NULL;

   try {
      // create the class from a progid string
      XmlDocument doc("Msxml2.DOMDocument.3.0");

      bstrXml = ::SysAllocString(L"<word>persnickety</word>");
      if (NULL == bstrXml) {
         throw gcnew OutOfMemoryException("bstrXml");
      }
      // detach the document object from the ref class
      pDoc = doc.GetDocument();
      // use unmanaged function and raw object to load xml
      Marshal::ThrowExceptionForHR(LoadXml(pDoc, bstrXml));
      // release reference to document object (but ref class still references it)
      pDoc->Release();
      pDoc = NULL;

      // call another function on the ref class
      doc.WriteDocument();
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
   finally {
      if (NULL != pDoc) {
         pDoc->Release();
      }

   }
}
<word>persnickety</word>

ptr:: QueryInterfaceptr::QueryInterface

소유 된 COM 개체를 쿼리하여 인터페이스에 연결 하 고 그 결과를 다른에 연결 com::ptr 합니다.Queries the owned COM object for an interface and attaches the result to another com::ptr.

template<class _other_type>
void QueryInterface(
   ptr<_other_type> % other
);

매개 변수Parameters

다른other
com::ptr인터페이스를 가져올입니다.The com::ptr that will get the interface.

예외Exceptions

내부적으로 QueryInterface 는 소유 된 COM 개체에서 호출 되 고 오류는에 HRESULT 의해 예외로 변환 됩니다 ThrowExceptionForHR .Internally, QueryInterface is called on the owned COM object and any error HRESULT is converted to an exception by ThrowExceptionForHR.

설명Remarks

이 메서드를 사용 하 여 현재 래퍼가 소유 하는 COM 개체의 다른 인터페이스에 대 한 COM 래퍼를 만들 수 있습니다.Use this method to create a COM wrapper for a different interface of the COM object owned by the current wrapper. 이 메서드는 QueryInterface 소유 된 com 개체를 호출 하 여 com 개체의 특정 인터페이스에 대 한 포인터를 요청 하 고 반환 된 인터페이스 포인터를 전달 된에 연결 합니다 com::ptr .This method calls QueryInterface through the owned COM object to request a pointer to a specific interface of the COM object and attaches the returned interface pointer to the passed-in com::ptr.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. WriteTopLevelNode멤버 함수는 QueryInterface 를 사용 하 여 로컬을로 채운 다음, com::ptr IXMLDOMNode com::ptr 노드의 이름과 텍스트 속성을 콘솔에 쓰는 전용 멤버 함수에 (추적 참조)를 전달 합니다.The WriteTopLevelNode member function uses QueryInterface to fill a local com::ptr with an IXMLDOMNode and then passes the com::ptr (by tracking reference) to a private member function that writes the node's name and text properties to the console.

// comptr_queryinterface.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   void LoadXml(String^ xml) {
      pin_ptr<const wchar_t> pinnedXml = PtrToStringChars(xml);
      BSTR bstr = NULL;

      try {
         // load some XML into our document
         bstr = ::SysAllocString(pinnedXml);
         if (NULL == bstr) {
            throw gcnew OutOfMemoryException;
         }
         VARIANT_BOOL bIsSuccessful = false;
         // use operator -> to call IXMODOMDocument member function
         Marshal::ThrowExceptionForHR(m_ptrDoc->loadXML(bstr, &bIsSuccessful));
      }
      finally {
         ::SysFreeString(bstr);
      }
   }

   // write the top level node to the console
   void WriteTopLevelNode() {
      com::ptr<IXMLDOMNode> ptrNode;

      // query for the top level node interface
      m_ptrDoc.QueryInterface(ptrNode);
      WriteNode(ptrNode);
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   // simplified function that only writes the node
   void WriteNode(com::ptr<IXMLDOMNode> % node) {
      BSTR bstr = NULL;

      try {
         // write out the name and text properties
         Marshal::ThrowExceptionForHR(node->get_nodeName(&bstr));
         String^ strName = gcnew String(bstr);
         Console::Write("<{0}>", strName);
         ::SysFreeString(bstr);
         bstr = NULL;

         Marshal::ThrowExceptionForHR(node->get_text(&bstr));
         Console::Write(gcnew String(bstr));
         ::SysFreeString(bstr);
         bstr = NULL;

         Console::WriteLine("</{0}>", strName);
      }
      finally {
         ::SysFreeString(bstr);
      }
   }

   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// use the ref class to handle an XML DOM Document object
int main() {
   try {
      // create the class from a progid string
      XmlDocument doc("Msxml2.DOMDocument.3.0");

      // stream some xml into the document
      doc.LoadXml("<word>persnickety</word>");

      // write the document to the console
      doc.WriteTopLevelNode();
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
}
<#document>persnickety</#document>

ptr:: Releaseptr::Release

COM 개체에서 소유 된 모든 참조를 해제 합니다.Releases all owned references on the COM object.

void Release();

설명Remarks

이 함수를 호출 하면 COM 개체에서 소유 된 모든 참조가 해제 되 고 COM 개체에 대 한 내부 핸들이로 설정 nullptr 됩니다.Calling this function releases all owned references on the COM object and sets the internal handle to the COM object to nullptr. COM 개체에 대 한 다른 참조가 없으면 소멸 됩니다.If no other references on the COM object exist, it will be destroyed.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. ReplaceDocument멤버 함수는를 사용 하 여 Release 새 문서를 연결 하기 전에 이전 문서 개체를 모두 해제 합니다.The ReplaceDocument member function uses Release to release any prior document object before attaching the new document.

// comptr_release.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   // replace currently held COM object with another one
   void ReplaceDocument(IXMLDOMDocument* pDoc) {
      // release current document object
      m_ptrDoc.Release();
      // attach the new document object
      m_ptrDoc.Attach(pDoc);
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// unmanaged function that creates a raw XML DOM Document object
IXMLDOMDocument* CreateDocument() {
   IXMLDOMDocument* pDoc = NULL;
   Marshal::ThrowExceptionForHR(CoCreateInstance(CLSID_DOMDocument30, NULL,
      CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (void**)&pDoc));
   return pDoc;
}

// use the ref class to handle an XML DOM Document object
int main() {
   IXMLDOMDocument* pDoc = NULL;

   try {
      // create the class from a progid string
      XmlDocument doc("Msxml2.DOMDocument.3.0");

      // get another document object from unmanaged function and
      // store it in place of the one held by our ref class
      pDoc = CreateDocument();
      doc.ReplaceDocument(pDoc);
      // no further need for raw object reference
      pDoc->Release();
      pDoc = NULL;
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
   finally {
      if (NULL != pDoc) {
         pDoc->Release();
      }
   }
}

ptr:: operator->ptr::operator->

소유 하는 COM 개체에서 메서드를 호출 하는 데 사용 되는 멤버 액세스 연산자입니다.Member access operator, used to call methods on the owned COM object.

_detail::smart_com_ptr<_interface_type> operator->();

반환 값Return value

smart_com_ptrCOM 개체에 대 한입니다.A smart_com_ptr to the COM object.

예외Exceptions

내부적으로 QueryInterface 는 소유 된 COM 개체에서 호출 되 고 오류는에 HRESULT 의해 예외로 변환 됩니다 ThrowExceptionForHR .Internally, QueryInterface is called on the owned COM object and any error HRESULT is converted to an exception by ThrowExceptionForHR.

설명Remarks

이 연산자를 사용 하면 소유 된 COM 개체의 메서드를 호출할 수 있습니다.This operator allows you to call methods of the owned COM object. smart_com_ptr자체 및를 자동으로 처리 하는 임시를 반환 합니다 AddRef Release .It returns a temporary smart_com_ptr that automatically handles its own AddRef and Release.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. WriteDocument함수는 operator-> 를 사용 하 여 get_firstChild 문서 개체의 멤버를 호출 합니다.The WriteDocument function uses operator-> to call the get_firstChild member of the document object.

// comptr_op_member.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   // add a reference to and return the COM object
   // but keep an internal reference to the object
   IXMLDOMDocument* GetDocument() {
      return m_ptrDoc.GetInterface();
   }

   // simplified function that only writes the first node
   void WriteDocument() {
      IXMLDOMNode* pNode = NULL;
      BSTR bstr = NULL;

      try {
         // use operator -> to call XML Doc member
         Marshal::ThrowExceptionForHR(m_ptrDoc->get_firstChild(&pNode));
         if (NULL != pNode) {
            // write out the xml
            Marshal::ThrowExceptionForHR(pNode->get_nodeName(&bstr));
            String^ strName = gcnew String(bstr);
            Console::Write("<{0}>", strName);
            ::SysFreeString(bstr);
            bstr = NULL;

            Marshal::ThrowExceptionForHR(pNode->get_text(&bstr));
            Console::Write(gcnew String(bstr));
            ::SysFreeString(bstr);
            bstr = NULL;

            Console::WriteLine("</{0}>", strName);
         }
      }
      finally {
         if (NULL != pNode) {
            pNode->Release();
         }
         ::SysFreeString(bstr);
      }
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// unmanaged function that loads XML into a raw XML DOM Document object
HRESULT LoadXml(IXMLDOMDocument* pDoc, BSTR bstrXml) {
   HRESULT hr = S_OK;
   VARIANT_BOOL bSuccess;
   hr = pDoc->loadXML(bstrXml, &bSuccess);
   if (S_OK == hr && !bSuccess) {
      hr = E_FAIL;
   }
   return hr;
}

// use the ref class to handle an XML DOM Document object
int main() {
   IXMLDOMDocument* pDoc = NULL;
   BSTR bstrXml = NULL;

   try {
      // create the class from a progid string
      XmlDocument doc("Msxml2.DOMDocument.3.0");

      bstrXml = ::SysAllocString(L"<word>persnickety</word>");
      if (NULL == bstrXml) {
         throw gcnew OutOfMemoryException("bstrXml");
      }
      // detach the document object from the ref class
      pDoc = doc.GetDocument();
      // use unmanaged function and raw object to load xml
      Marshal::ThrowExceptionForHR(LoadXml(pDoc, bstrXml));
      // release reference to document object (but ref class still references it)
      pDoc->Release();
      pDoc = NULL;

      // call another function on the ref class
      doc.WriteDocument();
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
   finally {
      if (NULL != pDoc) {
         pDoc->Release();
      }

   }
}
<word>persnickety</word>

ptr:: operator =ptr::operator=

COM 개체를에 연결 com::ptr 합니다.Attaches a COM object to a com::ptr.

ptr<_interface_type> % operator=(
   _interface_type * _right
);

매개 변수Parameters

_right_right
연결할 COM 인터페이스 포인터입니다.The COM interface pointer to attach.

반환 값Return value

에 대 한 추적 참조 com::ptr 입니다.A tracking reference on the com::ptr.

예외Exceptions

com::ptr COM 개체에 대 한 참조를 이미 소유 하 고 있으면이 operator= throw InvalidOperationException 됩니다.If the com::ptr already owns a reference to a COM object, operator= throws InvalidOperationException.

설명Remarks

COM 개체를에 할당 하는 com::ptr 것은 com 개체를 참조 하지만 해당 개체에 대 한 호출자 참조는 해제 하지 않습니다.Assigning a COM object to a com::ptr references the COM object but doesn't release the caller's reference to it.

이 연산자는와 동일한 결과를 가집니다 Attach .This operator has the same effect as Attach.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. ReplaceDocument멤버 함수는 먼저 Release 이전에 소유한 개체에 대해를 호출한 다음 operator= 를 사용 하 여 새 문서 개체를 연결 합니다.The ReplaceDocument member function first calls Release on any previously owned object and then uses operator= to attach a new document object.

// comptr_op_assign.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   // construct the internal com::ptr with a null interface
   // and use CreateInstance to fill it
   XmlDocument(String^ progid) {
      m_ptrDoc.CreateInstance(progid);
   }

   // replace currently held COM object with another one
   void ReplaceDocument(IXMLDOMDocument* pDoc) {
      // release current document object
      m_ptrDoc.Release();
      // attach the new document object
      m_ptrDoc = pDoc;
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// unmanaged function that creates a raw XML DOM Document object
IXMLDOMDocument* CreateDocument() {
   IXMLDOMDocument* pDoc = NULL;
   Marshal::ThrowExceptionForHR(CoCreateInstance(CLSID_DOMDocument30, NULL,
      CLSCTX_INPROC_SERVER, IID_IXMLDOMDocument, (void**)&pDoc));
   return pDoc;
}

// use the ref class to handle an XML DOM Document object
int main() {
   IXMLDOMDocument* pDoc = NULL;

   try {
      // create the class from a progid string
      XmlDocument doc("Msxml2.DOMDocument.3.0");

      // get another document object from unmanaged function and
      // store it in place of the one held by the ref class
      pDoc = CreateDocument();
      doc.ReplaceDocument(pDoc);
      // no further need for raw object reference
      pDoc->Release();
      pDoc = NULL;
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
   finally {
      if (NULL != pDoc) {
         pDoc->Release();
      }
   }
}

ptr:: operator boolptr::operator bool

조건식에 사용 하기 위한 연산자 com::ptr 입니다.Operator for using com::ptr in a conditional expression.

operator bool();

반환 값Return value

true 소유 된 COM 개체가 유효 하면이 고, 그렇지 않으면입니다. false 그렇지 않으면입니다.true if the owned COM object is valid; false otherwise.

설명Remarks

소유 하 고 있는 COM 개체는 유효 하지 않은 경우 유효 합니다 nullptr .The owned COM object is valid if it's not nullptr.

이 연산자는 _detail_class::_safe_bool bool 정수 계열 형식으로 변환할 수 없기 때문에 보다 안전한로 변환 합니다.This operator converts to _detail_class::_safe_bool which is safer than bool because it can't be converted to an integral type.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. CreateInstance멤버 함수는 operator bool 새 문서 개체를 만든 후를 사용 하 여 유효한 지 확인 하 고, 있는 경우 콘솔에 씁니다.The CreateInstance member function uses operator bool after creating the new document object to determine if it's valid and writes to the console if it is.

// comptr_op_bool.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   void CreateInstance(String^ progid) {
      if (!m_ptrDoc) {
         m_ptrDoc.CreateInstance(progid);
         if (m_ptrDoc) { // uses operator bool
            Console::WriteLine("DOM Document created.");
         }
      }
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// use the ref class to handle an XML DOM Document object
int main() {
   try {
      XmlDocument doc;
      // create the instance from a progid string
      doc.CreateInstance("Msxml2.DOMDocument.3.0");
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
}
DOM Document created.

ptr:: operator!ptr::operator!

소유 하는 COM 개체가 잘못 되었는지 여부를 확인 하는 연산자입니다.Operator to determine if the owned COM object is invalid.

bool operator!();

반환 값Return value

true 소유 된 COM 개체가 잘못 된 경우 false 그렇지 않으면입니다.true if the owned COM object is invalid; false otherwise.

설명Remarks

소유 하 고 있는 COM 개체는 유효 하지 않은 경우 유효 합니다 nullptr .The owned COM object is valid if it's not nullptr.

예제Example

이 예제에서는 com::ptr을 사용해서 해당 개인 멤버 IXMLDOMDocument 개체를 래핑하는 CLR 클래스를 구현합니다.This example implements a CLR class that uses a com::ptr to wrap its private member IXMLDOMDocument object. CreateInstance멤버 함수는 operator! 를 사용 하 여 문서 개체가 이미 소유 되었는지 여부를 확인 하 고 개체가 잘못 된 경우에만 새 인스턴스를 만듭니다.The CreateInstance member function uses operator! to determine if a document object is already owned, and only creates a new instance if the object is invalid.

// comptr_op_not.cpp
// compile with: /clr /link msxml2.lib
#include <msxml2.h>
#include <msclr\com\ptr.h>

#import <msxml3.dll> raw_interfaces_only

using namespace System;
using namespace System::Runtime::InteropServices;
using namespace msclr;

// a ref class that uses a com::ptr to contain an
// IXMLDOMDocument object
ref class XmlDocument {
public:
   void CreateInstance(String^ progid) {
      if (!m_ptrDoc) {
         m_ptrDoc.CreateInstance(progid);
         if (m_ptrDoc) {
            Console::WriteLine("DOM Document created.");
         }
      }
   }

   // note that the destructor will call the com::ptr destructor
   // and automatically release the reference to the COM object

private:
   com::ptr<IXMLDOMDocument> m_ptrDoc;
};

// use the ref class to handle an XML DOM Document object
int main() {
   try {
      XmlDocument doc;
      // create the instance from a progid string
      doc.CreateInstance("Msxml2.DOMDocument.3.0");
   }
   catch (Exception^ e) {
      Console::WriteLine(e);
   }
}
DOM Document created.