关于_bstr_t和 _variant_t

先看看代码：

class _bstr_t {
public:
// Constructors
//
_bstr_t() throw();                    //Default constructor
_bstr_t(const _bstr_t& s) throw();    // Copy constructor
_bstr_t(const char* s) throw(_com_error);          // Construct a _bstr_t from a const char*
_bstr_t(const wchar_t* s) throw(_com_error);       // Construct a _bstr_t from a const whar_t*
_bstr_t(const _variant_t& var) throw(_com_error);
_bstr_t(BSTR bstr, bool fCopy) throw(_com_error);  // Construct a _bstr_t from a BSTR.  If fCopy is FALSE, give control of
// data to the _bstr_t without making a new copy

// Destructor
//
~_bstr_t() throw();

// Assignment operators
//
_bstr_t& operator=(const _bstr_t& s) throw();                 // Default assign operator
_bstr_t& operator=(const char* s) throw(_com_error);          // Assign a const char* to a _bstr_t
_bstr_t& operator=(const wchar_t* s) throw(_com_error);       // Assign a const wchar_t* to a _bstr_t
_bstr_t& operator=(const _variant_t& var) throw(_com_error);

// Operators
//
_bstr_t& operator+=(const _bstr_t& s) throw(_com_error);     // Concatenate a _bstr_t onto this _bstr_t
_bstr_t operator+(const _bstr_t& s) const throw(_com_error);  // Return the concatenation of this _bstr_t with another _bstr_t

// Friend operators
//
friend _bstr_t operator+(const char* s1, const _bstr_t& s2) throw(_com_error);   // Return the concatenation of a const char* with a _bstr_t
friend _bstr_t operator+(const wchar_t* s1, const _bstr_t& s2) throw(_com_error);  // Return the concatenation of a const char* with a _bstr_t

// Extractors
//
operator const wchar_t*() const throw();        // Extract a const wchar_t*
operator wchar_t*() const throw();              // Extract a wchar_t*
operator const char*() const throw(_com_error); // Extract a const char_t*
operator char*() const throw(_com_error);       // Extract a char_t*

// Comparison operators
//
bool operator!() const throw();
bool operator==(const _bstr_t& str) const throw();
bool operator!=(const _bstr_t& str) const throw();
bool operator<(const _bstr_t& str) const throw();
bool operator>(const _bstr_t& str) const throw();
bool operator<=(const _bstr_t& str) const throw();
bool operator>=(const _bstr_t& str) const throw();

// Low-level helper functions
//
BSTR copy() const throw(_com_error);         // Extract a copy of the wrapped BSTR
unsigned int length() const throw();         // Return the length of the wrapped BSTR

// Binary string assign
//
void Assign(BSTR s) throw(_com_error);        // Binary string assign

private:
// Referenced counted wrapper
//
class Data_t {
public:
// Constructors
//
Data_t(const char* s) throw(_com_error);
Data_t(const wchar_t* s) throw(_com_error);
Data_t(BSTR bstr, bool fCopy) throw(_com_error);
Data_t(const _bstr_t& s1, const _bstr_t& s2) throw(_com_error);

// Reference counting routines
//
unsigned long AddRef() throw();
unsigned long Release() throw();

// Extractors
//
operator const wchar_t*() const throw();
operator const char*() const throw(_com_error);

// Low-level helper functions
//
const wchar_t* GetWString() const throw();
const char* GetString() const throw(_com_error);

BSTR Copy() const throw(_com_error);
void Assign(BSTR s) throw(_com_error);
unsigned int Length() const throw();
int Compare(const Data_t& str) const throw();

private:
wchar_t*		m_wstr;
mutable char*	m_str;
unsigned long	m_RefCount;

// Never allow default construction
//
Data_t() throw();

// Never allow copy
//
Data_t(const Data_t& s) throw();

// Prevent deletes from outside. Release() must be used.
//
~Data_t() throw();

void _Free() throw();
};

private:
// Reference counted representation
//
Data_t* m_Data;

private:
// Low-level utilities
//
void _AddRef() throw();
void _Free() throw();
int _Compare(const _bstr_t& str) const throw();
};

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

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_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型，VARIANT和BSTR这两种类型是COM中使用的数据类型。为了C++中的变量应用到ADO编程中，只能进行数据类型的转换。_variant_t和_bstr_t这两个类，就可以方便的把C++类型变量转换成COM中的变量了。

//_variant_t转WORD类型
BOOL AfxVariantConvert(WORD& val, const _variant_t& vt)
{
if (vt.vt == VT_UI2)
{
val = (WORD)vt.uiVal;

return TRUE;
}
else
{
val = 0;
return FALSE;
}
}

//_variant_t转DWORD类型
BOOL AfxVariantConvert(DWORD& val, const _variant_t& vt)
{
if (vt.vt == VT_UI4 )
{
val = (DWORD)vt.ulVal;

return TRUE;
}
else
{
val = 0;
return FALSE;
}
}

//_variant_t转DWORD64类型
BOOL AfxVariantConvert(DWORD64& val, const _variant_t& vt)
{
if (vt.vt != VT_UI8 )
{
val = (DWORD64)vt.ullVal;

return TRUE;
}
else
{
val = 0;
return FALSE;
}
}

//_variant_t转CString类型
BOOL AfxVariantConvert(CString& val, const _variant_t& vt)
{
if (vt.vt == VT_BSTR)
{
val = (LPCTSTR)vt.bstrVal;
//val=(LPCTSTR)(_bstr_t)vt;
return TRUE;
}
else
{
val = _T("");
return FALSE;
}
}

//_variant_t转BOOL类型
BOOL AfxVariantConvert(BOOL& val, const _variant_t& vt)
{
if (vt.vt == VT_BOOL)
{
val = vt.boolVal;
return TRUE;
}
else
{
val = FALSE;
return FALSE;
}
}

//_variant_t转CTime类型（精度变短，可能丢失数据）
BOOL AfxVariantConvert(CTime& val, const _variant_t& vt)
{
if (vt.vt == VT_DATE)
{
val = vt.date;
return TRUE;
}
else
{
val = NULL;
return FALSE;
}
}

//_variant_t转double类型
BOOL AfxVariantConvert(DOUBLE& val, const _variant_t& vt)
{
if (vt.vt == VT_R8)
{
val = vt.dblVal;
return TRUE;
}
else
{
val = 0;
return FALSE;
}
}

//_variant_t转byte类型
BOOL AfxVariantConvert(BYTE& val, const _variant_t& vt)
{
if (vt.vt == VT_UI1 || vt.vt == VT_I1)
{
val = vt.bVal;
return TRUE;
}
else
{
val = 0;
return FALSE;
}
}

//_variant_t转float类型
BOOL AfxVariantConvert( FLOAT& val, const _variant_t& vt )
{
if (vt.vt == VT_R4)
{
val = vt.fltVal;
return TRUE;
}
else
{
val = 0;
return FALSE;
}
}

//_variant_t转long类型
BOOL AfxVariantConvert( long& val,const _variant_t& vt )
{
if (vt.vt == VT_I4)
{
val = vt.lVal;
return TRUE;
}
else
{
val = 0;
return FALSE;
}
}

//_variant_t转INT64类型
BOOL AfxVariantConvert( INT64& val,const _variant_t& vt )
{
if (vt.vt == VT_I8)
{
val = vt.llVal;
return TRUE;
}
else
{
val = 0;
return FALSE;
}
}