如何创建和使用 CComPtr 和 CComQIPtr 实例

2024年8月28日 | 阅读 12 分钟

CComPtr 和 CComQIPtr 是 Microsoft COM 库（Windows API 的一部分）提供的智能指针，用于管理 COM 对象的生命周期。它们用于简化创建、使用和释放 COM 对象的过程，并帮助防止内存泄漏和悬空指针等常见错误。

在 C++ 中，指针是一个存储另一个变量内存地址的变量。指针用于存储动态分配内存的地址、高效地将大量数据传递给函数以及访问内存映射硬件。CComPtr 代表“COM 智能指针”，CComQIPtr 代表“COM QueryInterface 智能指针”。它们是 Microsoft COM 库（Windows API 的一部分）提供的智能指针，用于管理 COM 对象的生命周期。CComPtr 用于存储 COM 对象的地址并使用引用计数管理其生命周期。它提供了创建和释放 COM 对象的便捷方法，例如 CoCreateInstance 和 Release，并提供了隐式转换运算符以供与其他 COM API 一起使用。

CComQIPtr 用于查询 COM 对象以获取特定接口并使用引用计数管理其生命周期。它提供了一个方便的 QueryInterface 方法来查询对象，并提供了隐式转换运算符以供与其他 COM API 一起使用。CComPtr 和 CComQIPtr 都旨在简化在 C++ 中处理 COM 对象的过程，并帮助防止内存泄漏和悬空指针等常见错误。

为了更好地理解这个概念，让我们回顾一下指针的概念

以下是一个在 C++ 中使用指针的示例

#include <iostream>
int main() {
    // Declare an integer variable.
    int x = 10;
    // Declare a pointer to an integer.
    int* p = &x;
    // Print the value of the integer.
    std::cout << "x = " << x << std::endl;
    // Print the value stored at the address pointed to by the pointer.
    std::cout << "*p = " << *p << std::endl;
    // Change the value of the integer using the pointer.
    *p = 20;
    // Print the new value of the integer.
    std::cout << "x = " << x << std::endl;

    return 0;
}

输出

x = 10
*p = 10
x = 20

说明

在该示例中，指针 p 使用 int* 类型声明，这意味着它可以存储 int 变量的地址。& 运算符用于获取 x 变量的地址，* 运算符用于解引用指针并访问指针指向的地址中存储的值。

需要注意的是，指针必须谨慎使用，因为如果使用不当，它们可能是错误和安全漏洞的来源。例如，解引用空指针或指向未初始化内存的指针可能导致未定义行为。

C++ 中的对象是什么？

在 C++ 中，对象是类的实例。类是用户定义的类型，它定义了一组相似对象的属性和行为。对象是类类型的变量，它可以存储数据并调用类定义的行为。

以下是一个类定义和对象创建的 C++ 示例

#include <iostream>
// Define a class called "Person" with two data members: "name" and "age".
class Person
{
public:
    std::string name;
    int age;
};
int main()
{
    // Create an object of type "Person".
    Person p;

    // Set the data members of the object.
    p.name = "John Smith";
    p.age = 30;
// Print the data members of the object.
    std::cout << "Name: " << p.name << std::endl;
    std::cout << "Age: " << p.age << std::endl;
return 0;
}

输出

Name: John Smith
Age: 30

说明

在该示例中，Person 类定义了两个数据成员：name 和 age。main 函数创建了一个类型为 Person 的对象 p，并使用 . 运算符设置了其数据成员。然后将对象的类成员打印到控制台。

面向对象编程 (OOP) 是一种编程范例，它侧重于使用对象及其交互来设计和实现软件系统。它是许多现代编程语言（包括 C++）中使用的流行编程风格。

指针和对象之间的区别

指针和对象是 C++ 中的两个不同概念。

指针是存储另一个变量内存地址的变量。指针用于存储动态分配内存的地址、高效地将大量数据传递给函数以及访问内存映射硬件。

对象是类的实例。类是用户定义的类型，它定义了一组相似对象的属性和行为。对象是类类型的变量，它可以存储数据并调用类定义的行为。Java 和 C++ 都是面试准备的首选语言，并且 Java 编程语言中没有指针的概念。

以下是一个说明 C++ 中指针和对象之间区别的示例

#include <iostream>
// Define a class called "Person" with two data members: "name" and "age".
class Person
{
public:
    std::string name;
    int age;
};
int main()
{
    // Declare a pointer to an integer.
    int* p = new int;

    // Set the value pointed to by the pointer.
    *p = 10;
// Print the value stored at the address pointed to by the pointer.
    std::cout << "*p = " << *p << std::endl;
// Create an object of type "Person".
    Person person;
// Set the data members of the object.
    person.name = "John Smith";
    person.age = 30;
// Print the data members of the object.
    std::cout << "Name: " << person.name << std::endl;
    std::cout << "Age: " << person.age << std::endl;
return 0;
}

输出

*p = 10
Name: John Smith
Age: 30

说明

在该示例中，指针 p 用于存储整数的地址并访问该地址存储的值。对象 person 是 Person 类的实例，用于存储数据并调用类定义的行为。

需要注意的是，指针必须谨慎使用，因为如果使用不当，它们可能是错误和安全漏洞的来源。例如，解引用空指针或指向未初始化内存的指针可能导致未定义行为。另一方面，对象更容易使用和管理，但它们可能消耗更多内存，并且在某些情况下访问速度可能比指针慢。

如何使用 CComPtr 和 CComQIPtr

以下是一个如何使用 CComPtr 和 CComQIPtr 的示例

#include <atlcom.h>
#include <comdef.h>

int main()
{
    // Create an instance of a COM object.
    CComPtr<IUnknown> pUnknown;
    HRESULT hr = pUnknown.CoCreateInstance(__uuidof(SomeCOMObject));
    if (FAILED(hr))
    {
        // Handle error.
        return hr;
    }

    // Query the object for an interface.
    CComQIPtr<ISomeInterface> pSomeInterface = pUnknown;
    if (!pSomeInterface)
    {
        // Handle error.
        return E_NOINTERFACE;
    }

    // Use the interface.
    pSomeInterface->SomeMethod();

    // The CComPtr and CComQIPtr instances will automatically release the
    // COM object when they go out of scope.
}

说明

在该示例中，CComPtr<IUnknown> 用于创建 COM 对象实例，CComQIPtr<ISomeInterface> 用于查询对象以获取特定接口（ISomeInterface）。CComPtr 和 CComQIPtr 实例将在它们超出作用域时自动释放 COM 对象，从而确保对象得到正确清理。需要注意的是，CComPtr 和 CComQIPtr 只能与 COM 对象一起使用。它们不应与其他类型的对象或指针一起使用。

CComPtr 和 CComQIPtr 实例的优点

以下是使用 CComPtr 和 CComQIPtr 的一些优点

自动引用计数：CComPtr 和 CComQIPtr 使用引用计数来管理 COM 对象的生命周期。这意味着当指向它的最后一个 CComPtr 或 CComQIPtr 实例超出作用域时，COM 对象会被自动释放。这消除了手动调用 COM 对象的 Release 方法的需要，并有助于防止内存泄漏等常见错误。

示例

#include <atlcom.h>
#include <comdef.h>
#include <iostream>
int main()
{
    try
    {
        // Create an instance of a COM object using CComPtr.
        CComPtr<IUnknown> pUnknown;
        HRESULT hr = pUnknown.CoCreateInstance(__uuidof(SomeCOMObject));
        if (FAILED(hr))
        {
            throw _com_error(hr);
        }

        // The COM object will be automatically released when the CComPtr
        // instance goes out of scope, even if an exception is thrown.
    }
    catch (const _com_error& e)
    {
        // Handle COM exceptions.
        std::cerr << "Error: " << e.ErrorMessage() << std::endl;
    }
}

简化的对象创建和查询：CComPtr 和 CComQIPtr 提供了创建和查询 COM 对象的便捷方法，例如 CoCreateInstance 和 QueryInterface，这使得处理 COM 对象更加容易。

示例

#include <atlcom.h>
#include <comdef.h>
#include <iostream>
int main()
{
    try
    {
        // Create an instance of a COM object using CComPtr.
        CComPtr<IUnknown> pUnknown;
        HRESULT hr = pUnknown.CoCreateInstance(__uuidof(SomeCOMObject));
        if (FAILED(hr))
        {
            throw _com_error(hr);
        }

        // Query the object for an interface using CComQIPtr.
        CComQIPtr<ISomeInterface> pSomeInterface = pUnknown;
        if (!pSomeInterface)
        {
            throw _com_error(E_NOINTERFACE);
        }
// Use the interface.
        pSomeInterface->SomeMethod();
    }
    catch (const _com_error& e)
    {
        // Handle COM exceptions.
        std::cerr << "Error: " << e.ErrorMessage() << std::endl;
    }
}

安全高效：CComPtr 和 CComQIPtr 是使用模板类实现的，这意味着它们是类型安全的并且高效。它们还提供隐式转换运算符，这使得它们易于与其他 COM API 一起使用。

示例

#include <atlcom.h>
#include <comdef.h>
#include <iostream>
int main()
{
    try
    {
        // CComPtr and CComQIPtr are type-safe and efficient, and provide
        // implicit conversion operators.
        CComPtr<IUnknown> pUnknown;

异常安全：CComPtr 和 CComQIPtr 使用 RAII（资源获取即初始化）来确保即使在出现异常的情况下，COM 对象也能被正确释放。这使得在处理 COM 对象时更容易编写异常安全的代码。

总而言之，在 C++ 中使用 CComPtr 和 CComQIPtr 可以使处理 COM 对象更加容易和安全，并有助于防止内存泄漏和悬空指针等常见错误。

使用 CComPtr 和 CComQIPtr 的缺点

CComPtr 和 CComQIPtr 是 Microsoft COM 库（Windows API 的一部分）提供的智能指针，用于管理 COM 对象的生命周期。尽管它们有许多优点，但使用 CComPtr 和 CComQIPtr 也存在一些潜在的缺点。

依赖于 COM 库：CComPtr 和 CComQIPtr 是 COM 库的一部分，这意味着它们只能与 COM 对象一起使用。如果您不处理 COM 对象，或者您正在使用其他类型的智能指针，CComPtr 和 CComQIPtr 可能不适用。

示例

#include <atlcom.h>
#include <comdef.h>

int main()
{
    // CComPtr and CComQIPtr can only be used with COM objects.
    CComPtr<IUnknown> pUnknown;

    // This will not compile, because CComPtr and CComQIPtr cannot be used
    // with non-COM objects.
    // CComPtr<int> pInt;
}

功能有限：CComPtr 和 CComQIPtr 专门用于管理 COM 对象的生命周期，并且不提供与其他类型的智能指针（如共享指针或唯一指针）相比的完整功能。

示例

#include <atlcom.h>
#include <comdef.h>
#include <memory>

int main()
{
    // CComPtr and CComQIPtr do not provide all the functionality of other
    // smart pointers, such as shared pointers or unique pointers.
    CComPtr<IUnknown> pUnknown;
    std::shared_ptr<IUnknown> pSharedUnknown;

    // This will not compile, because CComPtr and CComQIPtr do not have
    // a `make_shared` function like shared pointers do.
    // pUnknown = std::make_shared<IUnknown>();
    // pSharedUnknown = pUnknown;
}

兼容性问题：CComPtr 和 CComQIPtr 是使用模板类实现的，这意味着它们可能与不支持模板的某些旧 C++ 编译器不兼容。

示例

#include <atlcom.h>
#include <comdef.h>

int main()
{
    // CComPtr and CComQIPtr are implemented using template classes, which
    // may not be compatible with some older C++ compilers that do not
    // support templates.
    CComPtr<IUnknown> pUnknown;

    // This will not compile on older C++ compilers that do not support
    // templates.
    // CComPtr<int> pInt;
}

开销：CComPtr 和 CComQIPtr 使用引用计数来管理 COM 对象的生命周期，

与使用原始指针相比，这可能会导致额外的开销。在大多数情况下，这可能不是一个问题，但如果您处理大量数据或性能关键代码，则需要考虑。

示例

#include <atlcom.h>
#include <comdef.h>
#include <chrono>
#include <iostream>

int main()
{
    // CComPtr and CComQIPtr use reference counting to manage the lifetime
    // of COM objects, which can result in additional overhead compared to
    // using raw pointers.
    CComPtr<IUnknown> pUnknown;
    IUnknown* pRawUnknown = nullptr;

    const int N = 100000000;

    // Measure the time it takes to create and release N COM objects using
    // CComPtr.
    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < N; ++i)
    {
        HRESULT hr = pUnknown.CoCreateInstance(__uuidof(SomeCOMObject));
        if (FAILED(hr))
        {
            std::cerr << "Error: " << _com_error(hr).ErrorMessage() << std::endl;
            return hr;
        }
    }
    auto end = std::chrono::high_resolution_clock::now();
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "CComPtr: " <<

总而言之，CComPtr 和 CComQIPtr 是处理 C++ 中 COM 对象的有用工具，但它们可能不适用于所有情况。重要的是要考虑项目的具体要求，并据此选择合适的工具和技术。

CComPtr 和 CComQIPtr 的实际应用

CComPtr 和 CComQIPtr 通常在处理 COM 对象（尤其是在 Windows 平台）的 C++ 应用程序中使用。它们通常用于简化创建、使用和释放 COM 对象的过程，并有助于防止内存泄漏和悬空指针等常见错误。

以下是一些可能使用 CComPtr 和 CComQIPtr 的实际应用示例

Windows 应用程序：CComPtr 和 CComQIPtr 经常在 Windows 应用程序中使用，这些应用程序使用 COM 对象与操作系统或其他系统组件进行交互。例如，Windows 应用程序可能使用 CComPtr 和 CComQIPtr 来创建和使用提供文件系统、注册表或网络访问的 COM 对象。

示例

#include <atlcom.h>
#include <comdef.h>
#include <iostream>
#include <shlobj.h>

int main()
{
    try
    {
        // Use CComPtr and CComQIPtr to create and use a COM object
        // that provides access to the file system.
        CComPtr<IShellItem> pShellItem;
        HRESULT hr = SHCreateItemFromParsingName(L"C:\\Windows", nullptr, __uuidof(IShellItem), reinterpret_cast<void**>(&pShellItem));
        if (FAILED(hr))
        {
            throw _com_error(hr);
        }

        CComQIPtr<IShellFolder> pShellFolder = pShellItem;
        if (!pShellFolder)
        {
            throw _com_error(E_NOINTERFACE);
        }

        // Use the interface to list the contents of the "C:\Windows" folder.
        CComPtr<IEnumIDList> pEnumIDList;
        hr = pShellFolder->EnumObjects(nullptr, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &pEnumIDList);
        if (FAILED(hr))
        {
            throw _com_error(hr);
        }

        for (;;)
        {
            CComPtr<IShellItem> pChildShellItem;
            ULONG fetched = 0;
            hr = pEnumIDList->Next(1, &pChildShellItem, &fetched);
            if (hr == S_FALSE)
            {
                break;
            }
            if (FAILED(hr))
            {
                throw _com_error(hr);
            }

            LPWSTR pName = nullptr;
            hr = pChildShellItem->GetDisplayName(SIGDN_NORMALDISPLAY, &pName);
            if (FAILED(hr))
            {
                throw _com_error(hr);
            }

            std::wcout << pName << std::endl;

            CoTaskMemFree(pName);
        }
    }
    catch (const _com_error& e)
    {
        // Handle COM exceptions.
        std::cerr << "Error: " << e.ErrorMessage() << std::endl;
    }
}

Office 应用程序：许多 Office 应用程序，如 Microsoft Word、Excel 和 PowerPoint，都是使用 COM 技术构建的，并使用 CComPtr 和 CComQIPtr 来管理 COM 对象的生命周期。例如，Office 应用程序可能使用 CComPtr 和 CComQIPtr 来创建和使用提供应用程序文档模型或用户界面访问的 COM 对象。

多媒体应用程序：CComPtr 和 CComQIPtr 通常在不使用 COM 对象访问音频和视频资源的应用程序中使用。例如，多媒体应用程序可能使用 CComPtr 和 CComQIPtr 来创建和使用提供音频和视频编解码器访问的 COM 对象，或者允许应用程序播放音频和视频流的 COM 对象。

总而言之，CComPtr 和 CComQIPtr 在使用 COM 对象的 C++ 应用程序中得到广泛使用，并且在 COM 是标准技术的 Windows 平台尤其有用。它们可以帮助简化处理 COM 对象的过程，并防止内存泄漏和悬空指针等常见错误。

C++ 中的 COM 是什么？

COM（组件对象模型）是由 Microsoft 开发的软件组件的二进制接口标准。它是一种平台无关、语言无关的构建和使用可以相互交互的软件组件的方式。

在 C++ 中，COM 通常用于访问各种系统服务和资源，如文件系统、注册表、网络等。它也常用于构建可扩展的应用程序，这些应用程序可以使用插件或扩展进行自定义或扩展。要使用 C++ 中的 COM，通常需要包含相应的头文件并链接 COM 库。在 C++ 中使用 COM 的最常见方法是 Microsoft COM 库，它提供了一组用于处理 COM 对象的 C++ 类和函数。Microsoft COM 库的一些关键特性包括

下一个主题C++ 中的命名约定

← 上一个下一个 →

如何创建和使用 CComPtr 和 CComQIPtr 实例

C++ 中的对象是什么？

指针和对象之间的区别

如何使用 CComPtr 和 CComQIPtr

CComPtr 和 CComQIPtr 实例的优点

使用 CComPtr 和 CComQIPtr 的缺点

CComPtr 和 CComQIPtr 的实际应用

C++ 中的 COM 是什么？

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

C++ 教程

C++ 控制语句

C++ 函数

C++ 数组

C++ 类和对象

C++ 构造函数

C++ 继承

C++ 多态

C++ 抽象

C++ 命名空间

C++ 模板

C++ 字符串

C++ 指针

信号处理

C++ 异常

C++ 文件与流

C++ STL 教程

面试题

选择题

C++ 程序

C++ STL Stack

C++ STL Bitset

C++ STL Deque

C++ STL List

C++ STL Map

C++ STL Math

C++ STL priority_queue

C++ STL Queue

C++ STL Multiset

C++ STL Multimap

C++ STL Set

C++ STD Strings

C++ STL Vector

C++ 操纵符

C++ STL Algorithms

C++ Algorithm

C++ Iterators

C++ 杂项

如何创建和使用 CComPtr 和 CComQIPtr 实例

C++ 中的对象是什么？

指针和对象之间的区别

如何使用 CComPtr 和 CComQIPtr

CComPtr 和 CComQIPtr 实例的优点

使用 CComPtr 和 CComQIPtr 的缺点

CComPtr 和 CComQIPtr 的实际应用

C++ 中的 COM 是什么？

相关帖子

C++ 特殊运算符

C++ std::tie

C++ 汉诺塔算法

C++ 反转数字程序

不使用算术、关系或条件运算符设置变量

C++ 字符数组转字符串

作用域解析运算符与 this 指针

C++ 科学计数法转十进制形式

C++ 拔比伦平方根算法

C++ static_assert

订阅 Tpoint Tech

联系信息

关注我们