关于_bstr_t和 _variant_t

最新推荐文章于 2020-03-25 09:48:26 发布

把大学没学完的学完

最新推荐文章于 2020-03-25 09:48:26 发布

阅读量571

点赞数

分类专栏： ADO

本文链接：https://blog.csdn.net/u014053368/article/details/23372287

版权

ADO 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

先看看代码：

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

把大学没学完的学完

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
关于_bstr_t和 _variant_t

先见源码：class _bstr_t {public: // Constructors // _bstr_t() throw(); _bstr_t(const _bstr_t& s) throw(); _bstr_t(const char* s) throw(_com_error); _bstr_t(const wchar_t* s) throw(_com_erro
复制链接

扫一扫

专栏目录