Variant Data Types

Variant variables are now supported by PowerBASIC, but their use is limited to that of a parameter assignment for conversion of data, for compatibility with other languages and applications, especially COM Objects.

Although notoriously lacking in efficiency, Variants are commonly used as COM Object parameters due to their flexibility.  You can think of a Variant as a kind of container, which can hold a variable of most any data type, numeric, string, or even an entire array.  This simplifies the process of calling procedures in a COM Object Server, as there is little need to worry about the myriad of possible data types for each parameter.

This flexibility comes at a great price in performance, so PowerBASIC limits their use to data storage and parameters only.  You may assign a numeric value, a string value, or even an entire array to a Variant with the LET statement, or its implied equivalent.  In the same way, you may assign one Variant value to another Variant variable, or even assign an array contained in a Variant to a compatible PowerBASIC array, or the reverse.

You may extract a simple scalar value from a Variant with the VARIANT# function for numeric values (regardless of the internal numeric data type), or with the VARIANT$ and VARIANT$$ functions for string values.  You may determine the type of data a Variant variable contains with the VARIANTVT function.  The following table summarizes the predefined (built-in) equates that can be used to examine a Variant:

Variants may not be used in an expression, be directly output (PRINT#, etc), or used as a member of a structure such as a User-Defined Type (UDT) or UNION, etc.  Instead, you must first extract the value with one of the above conversion functions, and use that acquired value for calculations.

Internally, a Variant is always 16-bytes in size, and may be passed as either a BYVAL or a BYREF parameter, at the programmer's discretion.  However, when a BYREF Variant is required as a parameter, only an explicit Variant variable may be passed by the calling code - a BYCOPY expression is not allowed.

All dynamic strings contained in a Variant must be Wide/Unicode, and PowerBASIC handles these conversions automatically through the LET statement and its implied equivalent.

There may be some cases where you wish to manipulate the internal structure of a Variant directly.  Though possible, you must exercise caution or a serious memory leak could occur.  Since a Variant could be the owner of a string, array, etc., you must always reset a Variant ([LET] VrntName = EMPTY) prior to manipulation with POKE, or pointers, etc.

When you use the standard PowerBASIC assignment syntax, for example: [LET] VrntName = 21, all this "housekeeping" is completely automatic and handled by PowerBASIC for you.

Every Variant variable must be explicitly declared with an appropriate statement such as: 

DIM xyz AS VARIANT or LOCAL xyz AS VARIANT

See Also

What is an object, anyway?

Just what is COM?

What is a COM component?