tagVARIANT、VARIANT、_variant_t和COleVariant

　　tagVARIANT是一个结构体struct：

 C++ Code： tagVARIANT

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

struct  tagVARIANT     {     union          {         struct  __tagVARIANT             {             VARTYPE vt;             WORD wReserved1;             WORD wReserved2;             WORD wReserved3;             union                  {                 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 __RPC_FAR *punkVal;                 IDispatch __RPC_FAR *pdispVal;                 SAFEARRAY __RPC_FAR *parray;                 BYTE __RPC_FAR *pbVal;                 SHORT __RPC_FAR *piVal;                 LONG __RPC_FAR *plVal;                 FLOAT __RPC_FAR *pfltVal;                 DOUBLE __RPC_FAR *pdblVal;                 VARIANT_BOOL __RPC_FAR *pboolVal;                 _VARIANT_BOOL __RPC_FAR *pbool;                 SCODE __RPC_FAR *pscode;                 CY __RPC_FAR *pcyVal;                 DATE __RPC_FAR *pdate;                 BSTR __RPC_FAR *pbstrVal;                 IUnknown __RPC_FAR *__RPC_FAR *ppunkVal;                 IDispatch __RPC_FAR *__RPC_FAR *ppdispVal;                 SAFEARRAY __RPC_FAR *__RPC_FAR *pparray;                 VARIANT __RPC_FAR *pvarVal;                 PVOID byref;                 CHAR cVal;                 USHORT uiVal;                 ULONG ulVal;                 INT intVal;                 UINT uintVal;                 DECIMAL __RPC_FAR *pdecVal;                 CHAR __RPC_FAR *pcVal;                 USHORT __RPC_FAR *puiVal;                 ULONG __RPC_FAR *pulVal;                 INT __RPC_FAR *pintVal;                 UINT __RPC_FAR *puintVal;                 struct  __tagBRECORD                     {                     PVOID pvRecord;                     IRecordInfo __RPC_FAR *pRecInfo;                     }   __VARIANT_NAME_4;                 }   __VARIANT_NAME_3;             }   __VARIANT_NAME_2;         DECIMAL decVal;         }   __VARIANT_NAME_1;     };

　　VARIANT是tagVARIANT的别名：

 C++ Code：VARIANT

1

typedef /* [wire_marshal] */ struct tagVARIANT VARIANT;

　　_variant_t  是VARIANT的包装管理类：

　　A _variant_t object encapsulates the VARIANT data type.

　　The class manages resource allocation and deallocation and makes function calls to VariantInit and VariantClear as appropriate.

 C++ Code： _variant_t类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144

////////////////////////////////////////////////////////////////////////////// // // Wrapper class for VARIANT // ////////////////////////////////////////////////////////////////////////////// /*  * VARENUM usage key,  *  * * [V] - may appear in a VARIANT  * * [T] - may appear in a TYPEDESC  * * [P] - may appear in an OLE property set  * * [S] - may appear in a Safe Array  * * [C] - supported by class _variant_t  *  *  *  VT_EMPTY            [V]   [P]        nothing  *  VT_NULL             [V]   [P]        SQL style Null  *  VT_I2               [V][T][P][S][C]  2 byte signed int  *  VT_I4               [V][T][P][S][C]  4 byte signed int  *  VT_R4               [V][T][P][S][C]  4 byte real  *  VT_R8               [V][T][P][S][C]  8 byte real  *  VT_CY               [V][T][P][S][C]  currency  *  VT_DATE             [V][T][P][S][C]  date  *  VT_BSTR             [V][T][P][S][C]  OLE Automation string  *  VT_DISPATCH         [V][T][P][S][C]  IDispatch *  *  VT_ERROR            [V][T]   [S][C]  SCODE  *  VT_BOOL             [V][T][P][S][C]  True=-1, False=0  *  VT_VARIANT          [V][T][P][S]     VARIANT *  *  VT_UNKNOWN          [V][T]   [S][C]  IUnknown *  *  VT_DECIMAL          [V][T]   [S][C]  16 byte fixed point  *  VT_I1                  [T]           signed char  *  VT_UI1              [V][T][P][S][C]  unsigned char  *  VT_UI2                 [T][P]        unsigned short  *  VT_UI4                 [T][P]        unsigned short  *  VT_I8                  [T][P]        signed 64-bit int  *  VT_UI8                 [T][P]        unsigned 64-bit int  *  VT_INT                 [T]           signed machine int  *  VT_UINT                [T]           unsigned machine int  *  VT_VOID                [T]           C style void  *  VT_HRESULT             [T]           Standard return type  *  VT_PTR                 [T]           pointer type  *  VT_SAFEARRAY           [T]          (use VT_ARRAY in VARIANT)  *  VT_CARRAY              [T]           C style array  *  VT_USERDEFINED         [T]           user defined type  *  VT_LPSTR               [T][P]        null terminated string  *  VT_LPWSTR              [T][P]        wide null terminated string  *  VT_FILETIME               [P]        FILETIME  *  VT_BLOB                   [P]        Length prefixed bytes  *  VT_STREAM                 [P]        Name of the stream follows  *  VT_STORAGE                [P]        Name of the storage follows  *  VT_STREAMED_OBJECT        [P]        Stream contains an object  *  VT_STORED_OBJECT          [P]        Storage contains an object  *  VT_BLOB_OBJECT            [P]        Blob contains an object  *  VT_CF                     [P]        Clipboard format  *  VT_CLSID                  [P]        A Class ID  *  VT_VECTOR                 [P]        simple counted array  *  VT_ARRAY            [V]              SAFEARRAY*  *  VT_BYREF            [V]              void* for local use  */ class _variant_t : public ::tagVARIANT { public:     // Constructors     //     _variant_t() throw(); _variant_t(const VARIANT& varSrc) throw(_com_error);     _variant_t(const VARIANT* pSrc) throw(_com_error);     _variant_t(const _variant_t& varSrc) throw(_com_error); _variant_t(VARIANT& varSrc, bool fCopy) throw(_com_error);          // Attach VARIANT if !fCopy _variant_t(short sSrc, VARTYPE vtSrc = VT_I2) throw(_com_error);    // Creates a VT_I2, or a VT_BOOL     _variant_t(long lSrc, VARTYPE vtSrc = VT_I4) throw(_com_error);     // Creates a VT_I4, a VT_ERROR, or a VT_BOOL     _variant_t(float fltSrc) throw();                                   // Creates a VT_R4     _variant_t(double dblSrc, VARTYPE vtSrc = VT_R8) throw(_com_error); // Creates a VT_R8, or a VT_DATE     _variant_t(const CY& cySrc) throw();                                // Creates a VT_CY     _variant_t(const _bstr_t& bstrSrc) throw(_com_error);               // Creates a VT_BSTR     _variant_t(const wchar_t *pSrc) throw(_com_error);                  // Creates a VT_BSTR     _variant_t(const char* pSrc) throw(_com_error);                     // Creates a VT_BSTR     _variant_t(IDispatch* pSrc, bool fAddRef = true) throw();           // Creates a VT_DISPATCH     _variant_t(bool bSrc) throw();                                      // Creates a VT_BOOL     _variant_t(IUnknown* pSrc, bool fAddRef = true) throw();            // Creates a VT_UNKNOWN     _variant_t(const DECIMAL& decSrc) throw();                          // Creates a VT_DECIMAL     _variant_t(BYTE bSrc) throw();                                      // Creates a VT_UI1 // Destructor     //     ~_variant_t() throw(_com_error); // Extractors     //     operator short() const throw(_com_error);           // Extracts a short from a VT_I2     operator long() const throw(_com_error);            // Extracts a long from a VT_I4     operator float() const throw(_com_error);           // Extracts a float from a VT_R4     operator double() const throw(_com_error);          // Extracts a double from a VT_R8     operator CY() const throw(_com_error);              // Extracts a CY from a VT_CY     operator _bstr_t() const throw(_com_error);         // Extracts a _bstr_t from a VT_BSTR     operator IDispatch*() const throw(_com_error);      // Extracts a IDispatch* from a VT_DISPATCH     operator bool() const throw(_com_error);            // Extracts a bool from a VT_BOOL     operator IUnknown*() const throw(_com_error);       // Extracts a IUnknown* from a VT_UNKNOWN     operator DECIMAL() const throw(_com_error);         // Extracts a DECIMAL from a VT_DECIMAL     operator BYTE() const throw(_com_error);            // Extracts a BTYE (unsigned char) from a VT_UI1          // Assignment operations     //     _variant_t& operator=(const VARIANT& varSrc) throw(_com_error);     _variant_t& operator=(const VARIANT* pSrc) throw(_com_error);     _variant_t& operator=(const _variant_t& varSrc) throw(_com_error); _variant_t& operator=(short sSrc) throw(_com_error);                // Assign a VT_I2, or a VT_BOOL     _variant_t& operator=(long lSrc) throw(_com_error);                 // Assign a VT_I4, a VT_ERROR or a VT_BOOL     _variant_t& operator=(float fltSrc) throw(_com_error);              // Assign a VT_R4     _variant_t& operator=(double dblSrc) throw(_com_error);             // Assign a VT_R8, or a VT_DATE     _variant_t& operator=(const CY& cySrc) throw(_com_error);           // Assign a VT_CY     _variant_t& operator=(const _bstr_t& bstrSrc) throw(_com_error);    // Assign a VT_BSTR     _variant_t& operator=(const wchar_t* pSrc) throw(_com_error);       // Assign a VT_BSTR     _variant_t& operator=(const char* pSrc) throw(_com_error);          // Assign a VT_BSTR     _variant_t& operator=(IDispatch* pSrc) throw(_com_error);           // Assign a VT_DISPATCH     _variant_t& operator=(bool bSrc) throw(_com_error);                 // Assign a VT_BOOL     _variant_t& operator=(IUnknown* pSrc) throw(_com_error);            // Assign a VT_UNKNOWN     _variant_t& operator=(const DECIMAL& decSrc) throw(_com_error);     // Assign a VT_DECIMAL     _variant_t& operator=(BYTE bSrc) throw(_com_error);                 // Assign a VT_UI1 // Comparison operations     //     bool operator==(const VARIANT& varSrc) const throw(_com_error);     bool operator==(const VARIANT* pSrc) const throw(_com_error); bool operator!=(const VARIANT& varSrc) const throw(_com_error);     bool operator!=(const VARIANT* pSrc) const throw(_com_error); // Low-level operations     //     void Clear() throw(_com_error); void Attach(VARIANT& varSrc) throw(_com_error);     VARIANT Detach() throw(_com_error); void ChangeType(VARTYPE vartype, const _variant_t* pSrc = NULL) throw(_com_error); void SetString(const char* pSrc) throw(_com_error); // used to set ANSI string };

　　COleVariant 也是对VARIANT的封装类：

 C++ Code：COleVariant类

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67

class COleVariant : public tagVARIANT { // Constructors public:     COleVariant(); COleVariant(const VARIANT& varSrc);     COleVariant(LPCVARIANT pSrc);     COleVariant(const COleVariant& varSrc); COleVariant(LPCTSTR lpszSrc);     COleVariant(LPCTSTR lpszSrc, VARTYPE vtSrc); // used to set to ANSI string     COleVariant(CString& strSrc); COleVariant(BYTE nSrc);     COleVariant(short nSrc, VARTYPE vtSrc = VT_I2);     COleVariant(long lSrc, VARTYPE vtSrc = VT_I4);     COleVariant(const COleCurrency& curSrc); COleVariant(float fltSrc);     COleVariant(double dblSrc);     COleVariant(const COleDateTime& timeSrc); COleVariant(const CByteArray& arrSrc);     COleVariant(const CLongBinary& lbSrc); COleVariant(LPCITEMIDLIST pidl); // Operations public:     void Clear();     void ChangeType(VARTYPE vartype, LPVARIANT pSrc = NULL);     void Attach(VARIANT& varSrc);     VARIANT Detach(); BOOL operator==(const VARIANT& varSrc) const;     BOOL operator==(LPCVARIANT pSrc) const; const COleVariant& operator=(const VARIANT& varSrc);     const COleVariant& operator=(LPCVARIANT pSrc);     const COleVariant& operator=(const COleVariant& varSrc); const COleVariant& operator=(const LPCTSTR lpszSrc);     const COleVariant& operator=(const CString& strSrc); const COleVariant& operator=(BYTE nSrc);     const COleVariant& operator=(short nSrc);     const COleVariant& operator=(long lSrc);     const COleVariant& operator=(const COleCurrency& curSrc); const COleVariant& operator=(float fltSrc);     const COleVariant& operator=(double dblSrc);     const COleVariant& operator=(const COleDateTime& dateSrc); const COleVariant& operator=(const CByteArray& arrSrc);     const COleVariant& operator=(const CLongBinary& lbSrc); void SetString(LPCTSTR lpszSrc, VARTYPE vtSrc); // used to set ANSI string operator LPVARIANT();     operator LPCVARIANT() const; // Implementation public:     ~COleVariant();     void _ClearCompat(); };