Using COM SafeArrays as regular local scope arrays in VBA

Question

So, I'm writing a VBA class for multidimensional arrays. A safearray is allocated using SafeArrayAllocDescriptorEx and SafeArrayAllocData and destroyed using SafeArrayDestroyDescriptor and SafeArrayDestroyData. A pointer to the safearray is stored inside the class.

I have a public method which exposes the array like this:

Tensor class

Private m_pSafeArray As LongPtr

'*** Bunch of allocation and destruction methods ***

Public Sub CreateAlias(ByRef adblAlias() As Double)
    CopyMemory ByVal VarPtrArray(adblAlias), m_pSafeArray, SIZEOF_VBA_LONGPTR
End Sub

Public Sub RemoveAlias(ByRef adblAlias() As Double)
    ZeroMemory ByVal VarPtrArray(adblAlias), SIZEOF_VBA_LONGPTR
End Sub

Which then can be used like this inside a module:

Dim A As Tensor
Dim A_() As Double

Set A = New Tensor
A.Resize Array(5, 10) '5x10 matrix

A.CreateAlias A_
MsgBox A_(1, 1)
A.RemoveAlias A_

If I don't call RemoveAlias at the end to wipe A_ then Excel will crash when A_ goes out of scope. It works fine, but recently I have found a way to go without calling RemoveAlias:

A new method inside the tensor class in which I add reference to the safearray before exposing it:

Public Function GetAlias() As Double()
    AddReference
    CopyMemory ByVal VarPtrArray(GetAlias), m_pSafeArray, SIZEOF_VBA_LONGPTR
End Function

Private Sub AddReference()
    Const PROCEDURE_NAME As String = "Tensor.AddReference"
    Dim lErrorCode As Long
    
    lErrorCode = SafeArrayAddRef(m_pSafeArray, m_pDataToRelease)
    If lErrorCode <> S_OK Then
        Err.Raise lErrorCode, PROCEDURE_NAME, GetSystemMessage(lErrorCode)
    End If
End Sub

Which can be used in this way:

A_ = tnsA.GetAlias
A_(1, 1) = 554

Excel does not crash.

The problem is I do not 100% understand what is happening with the reference count for my managed safearray. Does VBA decrement it for me when A_ goes out of scope, or it just builds up? (I am supposed to call SafeArrayReleaseDescriptor + SafeArrayReleaseData for each SafeArrayAddRef.)

It does not seem to hinder the safearray from being destroyed inside the class afterwards. I can call AddReference 10 times and still be able to SafeArrayDestroyDescriptor and SafeArrayDestroyData, or at least no errors are thrown by these two.

Is my memory dangling, hanging or leaking in any way? What are the risks that I am happily unaware of?

Btw, I can get locks counts for a safearray by reading its descriptor memory. How can I check reference count? Where is it stored?

Answer 1

To answer my own question after some trial and error:

SafeArrayDestroyData does not free data if SafeArrayAddRef was called before and was not properly released. Also, if safearray has flag FADF_STATIC SafeArrayDestroyData will also not free any memory. It just silently completes without any errors in both cases. Data remains in memory.

A.CreateAlias A_ & A.RemoveAlias A_ Is still the only way to make it work safely, but FADF_STATIC must not be used (unless you remove this feature flag manually before destroying).