VARIANT und VARIANTARG

Dieser Dokumentation für die Vorschau nur ist und in späteren Versionen geändert. Leere Themen wurden als Platzhalter eingefügt.]

Verwenden Sie VARIANTARG, um in DISPPARAMS und VARIANT Variante-Daten an, die als Verweis übergeben werden kann nicht übergebenen Argumente zu beschreiben. Wenn eine Variante verweist auf eine andere Variante mithilfe der VT_VARIANT | VT_BYREF Variablentyp die Variante, verwiesen wird kann nicht vom Typ VT_VARIANT auch sein | VT_BYREF. Varianten können als Wert übergeben werden, selbst wenn VARIANTARGs nicht. Die folgende Definition VARIANT ist in OAIDL.H Automatisierung Headerdatei beschrieben:

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_BYREF|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;
};

Extrahieren von Werten aus der VARIANTARGs vereinfachen, bietet Automatisierung eine Reihe von Funktionen zum Bearbeiten dieses Typs (siehe Konvertierung und Bearbeitung Funktionen (Component-Automatisierung) und Formatierung Routinen (Component-Automatisierung)). Verwendung dieser Funktionen wird dringend empfohlen, um sicherzustellen, dass Anwendungen konsistent Umwandlung Regeln angewendet werden.

vt Wert steuert die Interpretation der Union wie folgt:

Siehe auch

Konzepte

IDispatch-Datentypen und Strukturen

Datentypen, Strukturen und Enumerationen (Component-Automatisierung)