将多单元格范围值分配给变量

Question

I have a confusion about below statements

Dim x as variant
x=Range("A1:C3").value

After using above statement we can use x as a two dimensional array but if we declare x as an array like below

Dim x(1 to 3,1 to 3) as integer
x=Range("A1:C3").value 

Then using the above statemnet gives me compile time error stating Can't assign to an array .

My doubt is how the code runs fine when x is declared as variant but gives me error when it is declared as an array.

Answer 1

tl;dr - There isn't enough information provided by the return type definition for the compiler to determine how allocate memory or how to make determine offsets for casting at compile time.

In order to understand why these assignments are not compatible, it helps to understand the underlying data structures that VBA is using to represent each of them.

The .Value property of a Range returns a Variant . The type stored in the Variant is determined by the number of cells in that Range . If there's more than one cell, it returns a Variant containing an array of Variant . Note that is has to return a Variant - otherwise you would need to index into an array any time you wanted the value from a single cell.

VBA is a COM based language, so when you declare something as a Variant , it is stored in a COM VARIANT structure that consists of a VARTYPE the describes the contained data and either a pointer to the underlying data (types preceded with an asterisk in the union) or the data itself (types not preceded with a asterisk in the union). In memory, it looks like this:

So, when you use the assignment x = Range("A1:C3").Value , you get a VARTYPE that describes an array of Variant . This is important, as you'll see below.

If the Range only has one cell you also get a Variant , but it contains the underlying type - not an array.

When you declare an array in VBA, it is stored in a COM SAFEARRAY structure that describes the array in a way that makes it usable by other COM clients. In memory it looks like this (note that this is a one dimensional array - the SAFEARRAYBOUND at the end is actually an array with the number of elements in cDim):

That is basically what you get with the declaration Dim x(1 To 3, 1 To 3) As Integer (except there will be 2 SAFEARRAYBOUNDs at the end).

Note that there are 2 very important differences between the 2 data types. The loosely typed declaration Dim x As Variant allows the runtime to determine what is contained in the data area. In the case of the Range.Value assignment, you'll get a VARTYPE of array of Variant which is a compatible type (which is also why Dim x() As Variant will compile). The declaration Dim y(1 To 3, 1 To 3) As Integer is fixed at compile time . More importantly, since the size of a SAFEARRAY structure in memory is determined by the number of dimensions, the memory can be allocated by the compiler at compile time. However, the amount of memory allocated for an arbitrary SAFEARRAY structure returned by a COM call cannot. Furthermore, the size of the memory area pointed at is determined by the byte length of the contained type and the total number of elements. The compiler protects against the possibility of a mismatch by disallowing the assignment.

In fact, this is likely the reason why you can't directly obtain a pointer to a SAFEARRAY (the only way to do so is to cast to a Variant and manually dereference the pointer from it's data area):

Dim x(1 To 3, 1 To 3) As Integer
Debug.Print VarPtr(x)   '<- Type mismatch.

So breaking it down, you can't do this because the compiler doesn't have enough information to safely make the run-time cast. If you want to do a little poking under the hood, this code demonstrates what is happening under the hood:

Public Declare Sub CopyMemory Lib "kernel32" Alias _
    "RtlMoveMemory" (Destination As Any, Source As Any, _
    ByVal length As Long)

Public Type ComVariant
    VarType As Integer
    Reserved1 As Integer
    Reserved2 As Integer
    Reserved3 As Integer
    DataArea As Long
End Type

Public Sub ExamineVariables()
    Dim x As Variant
    x = Range("A1:C3").Value

    Dim testV As ComVariant
    CopyMemory testV, x, LenB(testV)
    Debug.Print testV.VarType    '= 8204 = 0x200C = VT_ARRAY & VT_VARIANT
    Debug.Print testV.DataArea   'Varies - is a SafeArray pointer.

    Dim y(1 To 3, 1 To 3) As Integer
    View2dArrayType y
End Sub

Public Sub View2dArrayType(vbArray As Variant)
    Dim testV As ComVariant
    'The VT_BYREF can be ignored - it is an artifact of the cast to Variant.
    CopyMemory testV, vbArray, LenB(testV)
    Debug.Print testV.VarType    '= 24578 = 0x6002 = VT_ARRAY & VT_BYREF & VT_I2
End Sub

Your first declaration is an array of Variant , where each element is 12 bytes long. Your second declaration is an array of Integer where each element is 2 bytes long. Neither the length of the returned memory area simply nor the appropriate cast can reliably determined at compile time. VBA is protecting you from access violations and/or runtime bad casts.

Answer 2

If I have understood your query correctly then the reason is very simple.

To transfer the data to an array from a worksheet it needs to be resizable. In your example, it is fixed.

Try this

Dim x() As Variant

ReDim x(1 To 3, 1 To 3)

x = Range("A1:C3").Value

Now why a Variant and not a String ? Because you do not know what is the data type of the cell contents.