COM+ Release方法计数未降至0及IUnknown计数异常问题咨询

Hey there! Let's break down your COM reference count confusion—this is a super common pitfall when working with COM, so you’re definitely not alone in scratching your head over this.

Why does the IUnknown from QueryInterface have an initial reference count of 3? #

There are a few likely reasons for this:

• Multiple prior interface acquisitions: Remember that every successful call to QueryInterface (including the implicit one from CoCreateInstance) increments the object’s reference count. For example:
  1. Calling CoCreateInstance gives you an initial interface pointer with a reference count of 1.
  2. If you then call QueryInterface to get a second interface (say, IB), the count jumps to 2.
  3. Calling QueryInterface again to retrieve IUnknown will bump it up to 3—each valid pointer you receive requires a corresponding Release, so the count tracks every active reference.
• Internal object references: Some COM objects might hold internal references to themselves (e.g., for caching, event subscriptions, or worker threads) during initialization. This would add to the count before you even start querying interfaces.

Why isn’t the final Release returning 0? #

The most common culprit here is an unaccounted-for reference somewhere in your code. Here’s what to check:

• Missing Release calls: Every pointer you get from CoCreateInstance or QueryInterface needs a matching Release. If you forgot to release one of your earlier interface pointers (like that IB pointer you retrieved before IUnknown), the count will never hit 0.
• Non-compliant COM object implementation: While rare, some custom COM objects might not strictly follow the reference count rules. For example, they might increment the count for internal purposes but not decrement it properly, or return a dummy value from Release instead of the actual current count.
• Smart pointer lifecycle issues: If you’re using COM smart pointers (like CComPtr), double-check that they’re not being copied or retained longer than intended. A stray copy could hold an extra reference that you don’t realize exists.

Key Points You Might Have Missed #

• Strict adherence to COM rules: Treat every interface pointer like a resource—acquire once, release once. Even IUnknown pointers from QueryInterface aren’t exempt.
• Track all pointers: Keep a log (or use debug prints) of every AddRef/Release call and their resulting counts. This will help you pinpoint where the count is being incremented without a matching decrement.
• Use debugging tools: In Visual Studio, you can enable COM debugging to track reference counts in real-time. This lets you see exactly when the count changes and which operations are causing it.

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