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();
};

tagVARIANT、VARIANT、_variant_t和COleVariant的更多相关文章

  1. VARIANT、 _variant_t、CComVariant、COleVariant、CDBVariant

    参考文章 http://blog.163.com/wslngcjsdxdr@126/blog/static/16219623020107634935586/ http://blog.csdn.net/ ...

  2. 转：MFC之COleVariant

    COleVariant 本质上是一个枚举,用同一种类型来表达不同的子类型.如同boost中的variant. 例子 COleVariant var(3.6f); float v = var.fltVa ...

  3. C++ VARIANT 学习小记录

    一:为什么会有这个? 目前,计算机语言有很多(大哥,为什么不能就那么一样呢?),如C++.Java,此外还有JavaScript.VBScript等脚本语言,它们自立门派,各自维护自己的数据类型. C ...

  4. 变体类型 Variant VARIANT

    变体类型 Variant VARIANT class RTL_DELPHIRETURN Variant: public TVarData typedef struct    tagVARIANT  V ...

  5. 常用的tagVARIANT结构【整理】

    VARIANT数据结构包含两个域(如果不考虑保留的域).vt域描述了第二个域的数据类型.为了使多种类型能够在第二个域中出现,我们定义了一个联合结构.所以,第二个域的名称随着vt域中输入值的不同而改变. ...

  6. COM技术中的VARIANT and VARIANTARG

    VARIANT and VARIANTARG Use VARIANTARG to describe arguments passed within DISPPARAMS, and VARIANT to ...

  7. CString-int-string-char-BSTR之间的转换

    一．CString, int, string, char*之间的转换 string 转 CString CString.Format("%s", string.c_str());c ...

  8. VC常用数据类型使用转换

    我们先定义一些常见类型变量借以说明 int i = 100; long l = 2001; float f=300.2; double d=12345.119; char username[]=&qu ...

  9. C++中各种数据量类型转换

    要在Unicode字符集环境下把CString转化为char* 方法: CString str = _T("D://校内项目//QQ.bmp");//////leo这个NB  可以 ...

随机推荐

  1. 【Android】自己定义ListView的Adapter报空指针异常解决方法

    刚刚使用ViewHolder的方法拉取ListView的数据,可是总会报异常. 细致查看代码.都正确. 后来打开adapter类,发现getView的返回值为null. 即return null. 将 ...

  2. 向Oracle数据库插入一条数据

    这几天搞了一下Oracle数据库.可能用sql server习惯了,感觉好不方便.PL的界面友好度比sql server差远了 .既然都收购了PL了 为什么不给它做好一点呢?各种不便.郁闷 向Orac ...

  3. read pread write pwrite open

    http://stackoverflow.com/questions/7592822/what-are-the-advantages-of-pwrite-and-pread-over-fwrite-a ...

  4. Date函数基础知识整理

    Date类型:1.Date.parse()接收一个表示日期的字符串参数,然后再根据这个字符串返回响应的日期的毫秒数:如:创建一个日期: <script> // var someDate=n ...

  5. selenium初探:WebDriverException解决方法探索(以Chrome浏览器|IE浏览器|Edge浏览器为例)

    环境参考:win10-64位, python3.6.3, selenium3.7 在初试selenium运行以下代码时 from selenium import webdriver browser = ...

  6. 队列——PowerShell版

    继续读啊哈磊<啊哈!算法>感悟系列——队列 地铁售票处排队,先来的人先到队首先买完先走,后来的人排在队尾等候后买完后走. 想买票,必须排在队尾:买完票,只能从队首离开. 这种先进先出(Fi ...

  7. c++之——抽象基类

    在一个虚函数的声明语句的分号前加上 =0:就可以将一个虚函数变成纯虚函数,其中,=0只能出现在类内部的虚函数声明语句处.纯虚函数只用声明,而不用定义,其存在就是为了提供接口,含有纯虚函数的类是抽象基类 ...

  8. c++全局函数 && 成员函数

    #include<iostream> using namespace std; class Test { public: Test(, ) { this->a = a; this-& ...

  9. perl学习笔记（一）

    关于Perl: Perl是一种高级.通用.直译式.动态的程序语言.最初设计者拉里·沃尔(Larry Wall)为了让在UNIX上进行报表处理的工作变得更方便,决定开发一个通用的脚本语言,而在1987年 ...

  10. 【Unity】使用SceneManager加载/切换场景

    一.直接切换 老版的(已弃用!): Application.LoadLevel(int index); // 参数是场景编号 Application.LoadLevel(string name); / ...