| C & C++ Programming | MFC Programming | Download | Site Index |


 

 

 

Supplementary Note For MFC Programming Module 24:

VARIANT and VARIANTARG

 

 

 

 

 

 

VARIANT and VARIANTARG

 

Use VARIANTARG to describe arguments passed within DISPPARAMS, and VARIANT to specify variant data that cannot be passed by reference. When a variant refers to another variant by using the VT_VARIANT | VT_BYREF vartype, the variant being referred to cannot also be of type VT_VARIANT | VT_BYREF. VARIANTs can be passed by value, even if VARIANTARGs cannot. The following definition of VARIANT is described in OAIDL.H automation header file:

 

 

typedef struct tagVARIANT VARIANT;

typedef struct tagVARIANT VARIANTARG;

struct tagVARIANT

    {

    union

        {

        struct __tagVARIANT

            {

            VARTYPE vt;

            WORD wReserved1;

            WORD wReserved2;

            WORD wReserved3;

            union

                {

                LONGLONG llVal;

                LONG lVal;

                BYTE bVal;

                SHORT iVal;

                FLOAT fltVal;

                DOUBLE dblVal;

                VARIANT_BOOL boolVal;

                _VARIANT_BOOL bool;

                SCODE scode;

                CY cyVal;

                DATE date;

                BSTR bstrVal;

                IUnknown *punkVal;

                IDispatch *pdispVal;

                SAFEARRAY *parray;

                BYTE *pbVal;

                SHORT *piVal;

                LONG *plVal;

                LONGLONG *pllVal;

                FLOAT *pfltVal;

                DOUBLE *pdblVal;

                VARIANT_BOOL *pboolVal;

                _VARIANT_BOOL *pbool;

                SCODE *pscode;

                CY *pcyVal;

                DATE *pdate;

                BSTR *pbstrVal;

                IUnknown **ppunkVal;

                IDispatch **ppdispVal;

                SAFEARRAY **pparray;

                VARIANT *pvarVal;

                PVOID byref;

                CHAR cVal;

                USHORT uiVal;

                ULONG ulVal;

                ULONGLONG ullVal;

                INT intVal;

                UINT uintVal;

                DECIMAL *pdecVal;

                CHAR *pcVal;

                USHORT *puiVal;

                ULONG *pulVal;

                ULONGLONG *pullVal;

                INT *pintVal;

                UINT *puintVal;

                struct __tagBRECORD

                    {

                    PVOID pvRecord;

                    IRecordInfo *pRecInfo;

                    }    __VARIANT_NAME_4;

                }    __VARIANT_NAME_3;

            }    __VARIANT_NAME_2;

        DECIMAL decVal;

        }    __VARIANT_NAME_1;

struct tagVARIANT 

   {

    union

       {

       struct __tagVARIANT

       {

          VARTYPE vt;

          WORD wReserved1;

          WORD wReserved2;

          WORD wReserved3;

   union {

      LONGLONG                llval;             // VT_I8.

      LONG                    lVal;              // VT_I4.

      BYTE                    bVal;              // VT_UI1.

      SHORT                   iVal;              // VT_I2.

      FLOAT                   fltVal;            // VT_R4.

      DOUBLE                  dblVal;            // VT_R8.

      VARIANT_BOOL            boolVal;           // VT_BOOL.

      _VARIANT_BOOL           bool;

      SCODE                   scode;             // VT_ERROR.

      CY                      cyVal;             // VT_CY.

      DATE                    date;              // VT_DATE.

      BSTR                    bstrVal;           // VT_BSTR.

      IUnknown                * punkVal;         // VT_UNKNOWN.

      IDispatch               * pdispVal;        // VT_DISPATCH.

      SAFEARRAY               * parray;          // VT_ARRAY|*.

      BYTE                    * pbVal;           // VT_BYREF|VT_UI1.

      SHORT                   * piVal;           // VT_BYREF|VT_I2.

      LONG                    * plVal;           // VT_BYREF|VT_I4.

      LONGLONG                * pllVal;          // VT_BYREF|VT_I8.

      FLOAT                   * pfltVal;         // VT_BYREF|VT_R4.

      DOUBLE                  * pdblVal;         // VT_BYREF|VT_R8.

      VARIANT_BOOL            * pboolVal;        // VT_BYREF|VT_BOOL.

      _VARIANT_BOOL           * pbool;

      SCODE                   * pscode;          // VT_BYREF|VT_ERROR.

      CY                      * pcyVal;          // VT_BYREF|VT_CY.

      DATE                    * pdate;           // VT_BYREF|VT_DATE.

      BSTR                    * pbstrVal;        // VT_BYREF|VT_BSTR.

      IUnknown                ** ppunkVal;       // VT_BYREF|VT_UNKNOWN.

      IDispatch               ** ppdispVal;      // VT_BYREF|VT_DISPATCH.

      SAFEARRAY               ** pparray;        // VT_ARRAY|*.

      VARIANT                 * pvarVal;         // VT_BYREF|VT_VARIANT.

      PVOID                   * byref;           // Generic ByRef.

      CHAR                    cVal;              // VT_I1.

      USHORT                  uiVal;             // VT_UI2.

      ULONG                   ulVal;             // VT_UI4.

      ULONGLONG               ullVal;            // VT_UI8.

      INT                     intVal;            // VT_INT.

      UINT                    uintVal;           // VT_UINT.

      DECIMAL                 * pdecVal          // VT_BYREF|VT_DECIMAL.

      CHAR                    * pcVal;           // VT_BYREF|VT_I1.

      USHORT                  * puiVal;          // VT_BYREF|VT_UI2.

      ULONG                   * pulVal;          // VT_BYREF|VT_UI4.

      ULONGLONG               * pullVal;         // VT_BYREF|VT_UI8.

      INT                     * pintVal;         // VT_BYREF|VT_INT.

      UINT                    * puintVal;        // VT_BYREF|VT_UINT.

      struct __tagBRECORD

      {

      PVOID                   pvRecord;

      IRecordInfo             *pRecInfo;

      }    __VARIANT_NAME_4;

   }    __VARIANT_NAME_3;

  }    __VARIANT_NAME_2;

  DECIMAL decVal;

}    __VARIANT_NAME_1;

};

};

To simplify extracting values from VARIANTARGs, Automation provides a set of functions for manipulating this type. Use of these functions is strongly recommended to ensure that applications apply consistent coercion rules. The vt value governs the interpretation of the union as follows:

 

Value

Description

VT_EMPTY

No value was specified. If an optional argument to an Automation method is left blank, do not pass a VARIANT of type VT_EMPTY. Instead, pass a VARIANT of type VT_ERROR with a value of DISP_E_PARAMNOTFOUND.

VT_EMPTY | VT_BYREF

Not valid.

VT_UI1

An unsigned 1-byte character is stored in bVal.

VT_UI1 | VT_BYREF

A reference to an unsigned 1-byte character was passed. A pointer to the value is in pbVal.

VT_UI2

An unsigned 2-byte integer value is stored in uiVal.

VT_UI2 | VT_BYREF

A reference to an unsigned 2-byte integer was passed. A pointer to the value is in puiVal.

VT_UI4

An unsigned 4-byte integer value is stored in ulVal.

VT_UI4 | VT_BYREF

A reference to an unsigned 4-byte integer was passed. A pointer to the value is in pulVal.

VT_UI8

An unsigned 8-byte integer value is stored in ullVal.

VT_UI8 | VT_BYREF

A reference to an unsigned 8-byte integer was passed. A pointer to the value is in pullVal.

VT_UINT

An unsigned integer value is stored in uintVal.

VT_UINT | VT_BYREF

A reference to an unsigned integer value was passed. A pointer to the value is in puintVal.

VT_INT

An integer value is stored in intVal.

VT_INT | VT_BYREF

A reference to an integer value was passed. A pointer to the value is in pintVal.

VT_I1

A 1-byte character value is stored in cVal.

VT_I1 | VT_BYREF

A reference to a 1-byte character was passed. A pointer the value is in pcVal.

VT_I2

A 2-byte integer value is stored in iVal.

VT_I2 | VT_BYREF

A reference to a 2-byte integer was passed. A pointer to the value is in piVal.

VT_I4

A 4-byte integer value is stored in lVal.

VT_I4 | VT_BYREF

A reference to a 4-byte integer was passed. A pointer to the value is in plVal.

VT_I8

A 8-byte integer value is stored in llVal.

VT_I4 | VT_BYREF

A reference to a 8-byte integer was passed. A pointer to the value is in pllVal.

VT_R4

An IEEE 4-byte real value is stored in fltVal.

VT_R4 | VT_BYREF

A reference to an IEEE 4-byte real value was passed. A pointer to the value is in pfltVal.

VT_R8

An 8-byte IEEE real value is stored in dblVal.

VT_R8 | VT_BYREF

A reference to an 8-byte IEEE real value was passed. A pointer to its value is in pdblVal.

VT_CY

A currency value was specified. A currency number is stored as 64-bit (8-byte), two's complement integer, scaled by 10,000 to give a fixed-point number with 15 digits to the left of the decimal point and 4 digits to the right. The value is in cyVal.

VT_CY | VT_BYREF

A reference to a currency value was passed. A pointer to the value is in pcyVal.

VT_BSTR

A string was passed; it is stored in bstrVal. This pointer must be obtained and freed by the BSTR functions.

VT_BSTR | VT_BYREF

A reference to a string was passed. A BSTR* that points to a BSTR is in pbstrVal. The referenced pointer must be obtained or freed by the BSTR functions.

VT_DECIMAL

Decimal variables are stored as 96-bit (12-byte) unsigned integers scaled by a variable power of 10. VT_DECIMAL uses the entire 16 bytes of the Variant.

VT_DECIMAL | VT_BYREF

A reference to a decimal value was passed. A pointer to the value is in pdecVal.

VT_NULL

A propagating null value was specified. (This should not be confused with the null pointer.) The null value is used for tri-state logic, as with SQL.

VT_NULL | VT_BYREF

Not valid.

VT_ERROR

An SCODE was specified. The type of the error is specified in scodee. Generally, operations on error values should raise an exception or propagate the error to the return value, as appropriate.

VT_ERROR | VT_BYREF

A reference to an SCODE was passed. A pointer to the value is in pscode.

VT_BOOL

A 16 bit Boolean (True/False) value was specified. A value of 0xFFFF (all bits 1) indicates True; a value of 0 (all bits 0) indicates False. No other values are valid.

VT_BOOL | VT_BYREF

A reference to a Boolean value. A pointer to the Boolean value is in pbool.

VT_DATE

A value denoting a date and time was specified. Dates are represented as double-precision numbers, where midnight, January 1, 1900 is 2.0, January 2, 1900 is 3.0, and so on. The value is passed in date. This is the same numbering system used by most spreadsheet programs, although some specify incorrectly that February 29, 1900 existed, and thus set January 1, 1900 to 1.0. The date can be converted to and from an MS-DOS representation using VariantTimeToDosDateTime().

VT_DATE | VT_BYREF

A reference to a date was passed. A pointer to the value is in pdate.

VT_DISPATCH

A pointer to an object was specified. The pointer is in pdispVal. This object is known only to implement IDispatch. The object can be queried as to whether it supports any other desired interface by calling QueryInterface() on the object. Objects that do not implement IDispatch should be passed using VT_UNKNOWN.

VT_DISPATCH | VT_BYREF

A pointer to a pointer to an object was specified. The pointer to the object is stored in the location referred to by ppdispVal.

VT_VARIANT

Invalid. VARIANTARGs must be passed by reference.

VT_VARIANT | VT_BYREF

A pointer to another VARIANTARG is passed in pvarVal. This referenced VARIANTARG, pvarVal, cannot be another VT_VARIANT|VT_BYREF. This value can be used to support languages that allow functions to change the types of variables passed by reference.

VT_UNKNOWN

A pointer to an object that implements the IUnknown interface is passed in punkVal.

VT_UNKNOWN | VT_BYREF

A pointer to the IUnknown interface is passed in ppunkVal. The pointer to the interface is stored in the location referred to by ppunkVal.

VT_ARRAY | <anything>

An array of data type <anything> was passed. (VT_EMPTY and VT_NULL are invalid types to combine with VT_ARRAY.) The pointer in pparray points to an array descriptor, which describes the dimensions, size, and in-memory location of the array. The array descriptor is never accessed directly, but instead is read and modified using functions.

 

Table 1.

 

 

 

 

 

 


| C & C++ Programming | MFC Programming | Download | Site Index |