_variant_t 类
头文件：comutil.h
//////////////////////////////////////////////////////////////////////////////
//
// 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) ;
_variant_t(const VARIANT* pSrc) ;
_variant_t(const _variant_t& varSrc) ;
_variant_t(VARIANT& varSrc, bool fCopy) ; // Attach VARIANT if !fCopy
_variant_t(short sSrc, VARTYPE vtSrc = VT_I2) ; // Creates a VT_I2, or a VT_BOOL
_variant_t(long lSrc, VARTYPE vtSrc = VT_I4) ; // 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) ; // Creates a VT_R8, or a VT_DATE
_variant_t(const CY& cySrc) throw(); // Creates a VT_CY
_variant_t(const _bstr_t& bstrSrc) ; // Creates a VT_BSTR
_variant_t(const wchar_t *pSrc) ; // Creates a VT_BSTR
_variant_t(const char* pSrc) ; // Creates a VT_BSTR
_variant_t(IDispatch* pSrc, bool fAddRef = true) throw(); // Creates a VT_DISPATCH
_variant_t(bool boolSrc) 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
_variant_t(char cSrc) throw(); // Creates a VT_I1
_variant_t(unsigned short usSrc) throw(); // Creates a VT_UI2
_variant_t(unsigned long ulSrc) throw(); // Creates a VT_UI4
_variant_t(int iSrc) throw(); // Creates a VT_INT
_variant_t(unsigned int uiSrc) throw(); // Creates a VT_UINT
#if (_WIN32_WINNT >= 0x0501)
_variant_t(__int64 i8Src) throw(); // Creates a VT_I8
_variant_t(unsigned __int64 ui8Src) throw(); // Creates a VT_UI8
#endif
// Destructor
//
~_variant_t() throw() ;
// Extractors
//
operator short() const ; // Extracts a short from a VT_I2
operator long() const ; // Extracts a long from a VT_I4
operator float() const ; // Extracts a float from a VT_R4
operator double() const ; // Extracts a double from a VT_R8
operator CY() const ; // Extracts a CY from a VT_CY
operator _bstr_t() const ; // Extracts a _bstr_t from a VT_BSTR
operator IDispatch*() const ; // Extracts a IDispatch* from a VT_DISPATCH
operator bool() const ; // Extracts a bool from a VT_BOOL
operator IUnknown*() const ; // Extracts a IUnknown* from a VT_UNKNOWN
operator DECIMAL() const ; // Extracts a DECIMAL from a VT_DECIMAL
operator BYTE() const ; // Extracts a BTYE (unsigned char) from a VT_UI1
operator VARIANT() const throw();
operator char() const ; // Extracts a char from a VT_I1
operator unsigned short() const ; // Extracts a unsigned short from a VT_UI2
operator unsigned long() const ; // Extracts a unsigned long from a VT_UI4
operator int() const ; // Extracts a int from a VT_INT
operator unsigned int() const ; // Extracts a unsigned int from a VT_UINT
#if (_WIN32_WINNT >= 0x0501)
operator __int64() const ; // Extracts a __int64 from a VT_I8
operator unsigned __int64() const ; // Extracts a unsigned __int64 from a VT_UI8
#endif
// Assignment operations
//
_variant_t& operator=(const VARIANT& varSrc) ;
_variant_t& operator=(const VARIANT* pSrc) ;
_variant_t& operator=(const _variant_t& varSrc) ;
_variant_t& operator=(short sSrc) ; // Assign a VT_I2, or a VT_BOOL
_variant_t& operator=(long lSrc) ; // Assign a VT_I4, a VT_ERROR or a VT_BOOL
_variant_t& operator=(float fltSrc) ; // Assign a VT_R4
_variant_t& operator=(double dblSrc) ; // Assign a VT_R8, or a VT_DATE
_variant_t& operator=(const CY& cySrc) ; // Assign a VT_CY
_variant_t& operator=(const _bstr_t& bstrSrc) ; // Assign a VT_BSTR
_variant_t& operator=(const wchar_t* pSrc) ; // Assign a VT_BSTR
_variant_t& operator=(const char* pSrc) ; // Assign a VT_BSTR
_variant_t& operator=(IDispatch* pSrc) ; // Assign a VT_DISPATCH
_variant_t& operator=(bool boolSrc) ; // Assign a VT_BOOL
_variant_t& operator=(IUnknown* pSrc) ; // Assign a VT_UNKNOWN
_variant_t& operator=(const DECIMAL& decSrc) ; // Assign a VT_DECIMAL
_variant_t& operator=(BYTE bSrc) ; // Assign a VT_UI1
_variant_t& operator=(char cSrc) ; // Assign a VT_I1
_variant_t& operator=(unsigned short usSrc) ; // Assign a VT_UI2
_variant_t& operator=(unsigned long ulSrc) ; // Assign a VT_UI4
_variant_t& operator=(int iSrc) ; // Assign a VT_INT
_variant_t& operator=(unsigned int uiSrc) ; // Assign a VT_UINT
#if (_WIN32_WINNT >= 0x0501)
_variant_t& operator=(__int64 i8Src) ; // Assign a VT_I8
_variant_t& operator=(unsigned __int64 ui8Src) ; // Assign a VT_UI8
#endif
// Comparison operations
//
bool operator==(const VARIANT& varSrc) const throw();
bool operator==(const VARIANT* pSrc) const throw();
bool operator!=(const VARIANT& varSrc) const throw();
bool operator!=(const VARIANT* pSrc) const throw();
// Low-level operations
//
void Clear() ;
void Attach(VARIANT& varSrc) ;
VARIANT Detach() throw();
VARIANT& GetVARIANT() throw();
VARIANT* GetAddress() ;
void ChangeType(VARTYPE vartype, const _variant_t* pSrc = NULL) ;
void SetString(const char* pSrc) ; // used to set ANSI string
};
_bstr_t 类
头文件：comutil.h
//////////////////////////////////////////////////////////////////////////////
//
// Wrapper class for BSTR
//
//////////////////////////////////////////////////////////////////////////////
class _bstr_t {
public:
// Constructors
//
_bstr_t() throw();
_bstr_t(const _bstr_t& s) throw();
_bstr_t(const char* s) ;
_bstr_t(const wchar_t* s) ;
_bstr_t(const _variant_t& var) ;
_bstr_t(BSTR bstr, bool fCopy) ;
// Destructor
//
~_bstr_t() throw();
// Assignment operators
//
_bstr_t& operator=(const _bstr_t& s) throw();
_bstr_t& operator=(const char* s) ;
_bstr_t& operator=(const wchar_t* s) ;
_bstr_t& operator=(const _variant_t& var) ;
// Operators
//
_bstr_t& operator+=(const _bstr_t& s) ;
_bstr_t operator+(const _bstr_t& s) const ;
// Friend operators
//
friend _bstr_t operator+(const char* s1, const _bstr_t& s2) ;
friend _bstr_t operator+(const wchar_t* s1, const _bstr_t& s2) ;
// Extractors
//
operator const wchar_t*() const throw();
operator wchar_t*() const throw();
operator const char*() const ;
operator char*() const ;
// 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(bool fCopy = true) const ;
unsigned int length() const throw();
// Binary string assign
//
void Assign(BSTR s) ;
// Get the physical BSTR
//
BSTR& GetBSTR() ;
BSTR* GetAddress() ;
// Attach to the internal BSTR w/o copying
//
void Attach(BSTR s) ;
// Detach the internal BSTR
//
BSTR Detach();
private:
// Referenced counted wrapper
//
class Data_t {
public:
// Constructors
//
Data_t(const char* s) ;
Data_t(const wchar_t* s) ;
Data_t(BSTR bstr, bool fCopy) ;
Data_t(const _bstr_t& s1, const _bstr_t& s2) ;
// Reference counting routines
//
unsigned long AddRef() throw();
unsigned long Release() throw();
unsigned long RefCount() const throw();
// Extractors
//
operator const wchar_t*() const throw();
operator const char*() const ;
// Low-level helper functions
//
const wchar_t* GetWString() const throw();
wchar_t*& GetWString() throw();
const char* GetString() const ;
BSTR Copy() const ;
void Assign(BSTR s) ;
void Attach(BSTR s) throw();
unsigned int Length() const throw();
int Compare(const Data_t& str) const throw();
// Exception agnostic wrapper for new
//
void* operator new(size_t sz);
private:
BSTR 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();
};
扫一扫
4293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
