返回非空OLECHAR*后调用CoTaskMemFree是否会产生悬空指针？

针对你的需求，我们可以通过**RAII（资源获取即初始化）**机制自动管理内存，既避免重复编写GUID生成与释放代码，又彻底解决悬空指针和内存泄漏问题。以下是几种实用方案：

方案一：使用std::unique_ptr自定义删除器（推荐） #

利用标准库智能指针，指定CoTaskMemFree作为删除器，让智能指针自动管理内存生命周期，无需手动调用释放函数。

#include <memory>
#include <objbase.h>
#include <wchar.h>

// 返回智能指针，自动释放内存
std::unique_ptr<OLECHAR, decltype(&CoTaskMemFree)> generateGUIDString()
{
    GUID guid;
    HRESULT hr = CoCreateGuid(&guid);
    if (FAILED(hr)) {
        return {nullptr, CoTaskMemFree};
    }

    OLECHAR* guidString = nullptr;
    hr = StringFromCLSID(guid, &guidString);
    if (FAILED(hr)) {
        return {nullptr, CoTaskMemFree};
    }

    return {guidString, CoTaskMemFree};
}

调用示例 #

auto guidStr = generateGUIDString();
if (guidStr) {
    // 通过get()获取原始指针使用
    wprintf(L"生成的GUID：%s\n", guidStr.get());
}
// 智能指针超出作用域时自动调用CoTaskMemFree，无需手动释放

此方案优势：

• 无需手动管理内存，彻底避免遗忘释放导致的泄漏
• 智能指针释放后内部指针自动置空，不会出现悬空指针
• 代码简洁，复用性强

方案二：自定义RAII类 #

如果需要同时管理原始GUID和字符串，可封装一个专用类，将内存管理逻辑完全封装在类内部：

#include <objbase.h>
#include <wchar.h>

class GuidString {
public:
    GuidString() {
        HRESULT hr = CoCreateGuid(&guid_);
        if (SUCCEEDED(hr)) {
            hr = StringFromCLSID(guid_, &str_);
        }
        // 失败时将字符串指针置空
        if (FAILED(hr)) {
            str_ = nullptr;
        }
    }

    // 析构时自动释放内存
    ~GuidString() {
        if (str_) {
            CoTaskMemFree(str_);
            str_ = nullptr;
        }
    }

    // 禁用拷贝，避免二次释放
    GuidString(const GuidString&) = delete;
    GuidString& operator=(const GuidString&) = delete;

    // 支持移动语义，允许转移所有权
    GuidString(GuidString&& other) noexcept 
        : str_(other.str_), guid_(other.guid_) {
        other.str_ = nullptr;
    }

    GuidString& operator=(GuidString&& other) noexcept {
        if (this != &other) {
            // 先释放当前内存
            if (str_) {
                CoTaskMemFree(str_);
            }
            str_ = other.str_;
            guid_ = other.guid_;
            other.str_ = nullptr;
        }
        return *this;
    }

    // 获取GUID字符串指针
    const OLECHAR* get() const noexcept {
        return str_;
    }

    // 获取原始GUID
    const GUID& getGuid() const noexcept {
        return guid_;
    }

    // 判断是否生成成功
    bool isValid() const noexcept {
        return str_ != nullptr;
    }

private:
    GUID guid_;
    OLECHAR* str_ = nullptr;
};

调用示例 #

GuidString guidStr;
if (guidStr.isValid()) {
    wprintf(L"生成的GUID：%s\n", guidStr.get());
    // 如需使用原始GUID
    // const GUID& rawGuid = guidStr.getGuid();
}
// 对象销毁时自动释放内存，无需手动操作

方案三：明确调用约定（不推荐） #

如果坚持返回原始指针，必须在函数注释中明确告知调用者需要手动释放，同时调用者释放后要立即将指针置空：

#include <objbase.h>

// 注意：返回的OLECHAR*由CoTaskMemAlloc分配，调用者必须使用CoTaskMemFree释放
OLECHAR* generateGUIDString()
{
    GUID guid;
    HRESULT hr = CoCreateGuid(&guid);
    if (FAILED(hr)) {
        return nullptr;
    }

    OLECHAR* guidString = nullptr;
    hr = StringFromCLSID(guid, &guidString);
    return guidString;
}

调用示例 #

OLECHAR* guidStr = generateGUIDString();
if (guidStr) {
    wprintf(L"生成的GUID：%s\n", guidStr);
    // 使用完毕必须释放
    CoTaskMemFree(guidStr);
    guidStr = nullptr; // 置空避免悬空指针
}

此方案依赖调用者严格遵守约定，容易因遗忘释放或误用已释放指针导致问题，仅适用于简单场景。

内容的提问来源于stack exchange，提问作者Samuil Dimitrov