What Is the Size of Variant Data Type in VB?


Angela Bailey

The size of the Variant data type in VB (Visual Basic) is a topic that often confuses programmers. The Variant data type is unique in that it can hold any type of data, including numbers, strings, dates, and even objects. This flexibility comes at a cost, as the size of a Variant can vary depending on the actual data it contains.

Understanding the Size of Variant:
The size of a Variant depends on the specific data it holds. In VB, a Variant can be either 16 bytes or 22 bytes in size.

When a Variant holds numeric values, such as integers or floating-point numbers, it requires 16 bytes of memory. On the other hand, when a Variant contains non-numeric values like strings or dates, it expands to 22 bytes.

Numeric Variants:
Numeric variants are primarily used for mathematical calculations and storing numeric values. They occupy less memory compared to non-numeric variants. When you assign an integer or a floating-point value to a numeric variant, it will take up 16 bytes of memory.

Non-Numeric Variants:
Non-numeric variants are used for storing string values or dates. These variants require more memory compared to their numeric counterparts due to additional information they need to store. When you assign a string or date value to a non-numeric variant, it will expand to 22 bytes.

Let’s take an example to understand this better:

Dim numVariant As Variant
Dim strVariant As Variant

numVariant = 10
strVariant = “Hello”

Debug.Print “Size of numVariant: ” & LenB(numVariant)
Debug.Print “Size of strVariant: ” & LenB(strVariant)

In this example, we have declared two variants – `numVariant` and `strVariant`. The `numVariant` is assigned an integer value of 10, while the `strVariant` is assigned a string value of “Hello”. By using the `LenB` function, we can determine the size of each variant in bytes.

When this code is executed, it will output:

Size of numVariant: 16
Size of strVariant: 22

As expected, the numeric variant (`numVariant`) occupies 16 bytes, while the non-numeric variant (`strVariant`) expands to 22 bytes.

  • Summary:

In conclusion, the size of the Variant data type in VB depends on the specific data it holds. Numeric variants take up 16 bytes, while non-numeric variants expand to 22 bytes. It’s important to be mindful of these differences when working with Variants, especially in scenarios where memory usage is a concern.

Additional Considerations:

While Variants provide flexibility and convenience in handling different data types within a single variable, they also come with some drawbacks. The use of Variants can lead to slower performance compared to explicitly typed variables due to the additional overhead involved in managing their dynamic nature.

It’s generally recommended to use explicitly typed variables whenever possible to improve code readability and performance. By declaring variables with specific data types, you can ensure better memory allocation and avoid unnecessary conversions or runtime errors.


In this article, we explored the size of the Variant data type in VB. We learned that Numeric Variants occupy 16 bytes, while Non-Numeric Variants expand to 22 bytes.

It’s crucial to consider these sizes and their impact on memory usage when using Variants in your VB programs. Additionally, it’s worth considering whether using explicitly typed variables would be more suitable for your specific use case.

Discord Server - Web Server - Private Server - DNS Server - Object-Oriented Programming - Scripting - Data Types - Data Structures

Privacy Policy