scope of objects in a collection

Questions about an object's scope when involved with collections


Lets assume I have a subroutine whose input argument is an empty collection.
Within the subroutine an object is declared and instantiated and then added
to the collection.

When the subroutine returns to the calling program, are the objects within the
collection still in the collection now found in the calling program?

Assume that I did not declare the object being collected as having module scope
but only local scope.

In the old days, forms of global variables were not good practice. But I do not see
how else to preserve the object being collected other than to make its scope at module level

public sub (ByRef ACollection as collection)

	Dim A as SpecialObject
	
	Set A as new SpecialObject

	ACollection.add (A)
End sub

are the objects within the
collection still in the collection now found in the calling program

Simple enough to test...

Sub x()

   Dim c As New Collection
   
   y c
   
   MsgBox c.Item(1).Name
   MsgBox c.Item(2).Name
   
End Sub

Sub y(ByRef c As Collection)

   Dim o As Object
   
   Set o = CreateObject("Word.Application")
   c.Add o
   
   Set o = Nothing
   Set o = CreateObject("Excel.Application")
   c.Add o
   
End Sub

You will be left with hidden instances of Word and Excel running in the background but the objects themselves will continue to exist as long as there's a reference to them somewhere.

It's not a copy of the object, it's an additional reference.

An object will remain in memory as long as there is a reference to it held somewhere- each time you create a reference to it, a reference counter is incremented, and each time a reference is removed, the counter is decremented. An object will not be destroyed before that counter reaches 0. When you add the object variable to the collection, you create a copy of that pointer, thereby incrementing the reference count to 2. So even though the O variable has procedural scope, when it is cleared at the end of the procedure, that only reduces the reference count back to 1, so the object itself remains in memory due to the additional reference being held.