Cómo definir _bstr_t y _variant_t

Definición de _bstr_t: COMUTIL.HH

clase _bstr_t {

público:

// Constructor

//

_bstr_t() throw();

_bstr_t( const _bstr_tamp; s) throw();

_bstr_t(const char* s) throw(_com_error);

_bstr_t(const wchar_t* s) throw(_com_error);

_bstr_t(const _variant_tamp; var) throw(_com_error);

_bstr_t(BSTR bstr, bool fCopy) throw (_com_error);

// Destructor

//

~_bstr_t() throw();

/ / Operador de asignación

//

_bstr_tamp; operador=(const _bstr_tamp; s) throw();

_bstr_ operador=( const char* s ) throw(_com_error);

_bstr_tamp; operator=(const wchar_t* s) throw(_com_error);

_bstr_tamp.operator=(const _variant_tamp; var) throw (_com_error);

// Operador

//

_bstr_tamp; operador = (const _bstr_tamp; s) throw(_com_error);

_bstr_t operador (const _bstr_tamp; s) const throw(_com_error);

// operador amigo

//

operador amigo _bstr_t (const char* s1, const _bstr_tamp ; s2) throw(_com_error);

amigo _bstr_t operador (const wchar_t* s1, const _bstr_tamp; s2) throw(_com_error);

// Extractores

//

operador const wchar_t*() const throw();

operador wchar_t*() const throw()

operador const char*( ) const throw(_com_error);

operador char*() const throw(_com_error);

// Operador de comparación

//

operador bool! ()c

onst throw();

operador bool==(const _bstr_tamp; str) const throw();

operador bool!=(const _bstr_tamp; str) const throw();

operador bool! =(const _bstr_t amp; str) const throw();

bool operatorlt; (const _bstr_tamp; str) const throw();

bool operatorgt; const throw();

bool operatorlt;=(const _bstr_tamp; str) const throw();

bool operatorgt;=(const _bstr_tamp; str) const throw();

bool operatorgt;=(const _bstr_tamp; str) const throw();

// Función auxiliar de bajo nivel

//

BSTR copy() const throw(_com_error);

unsigned int length() const throw();

// Asignación de cadena binaria

//< / p>

void Assign(BSTR s) throw(_com_error);

privado:

// contenedor contado referenciado

//

clase Data_t {

public:

// Constructor

//

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_tamp; s1, const _bstr_tamp; s2) throw (_com_error);

// Rutina de recuento de referencias

//

AddRef largo sin signo ( ) throw();

Lanzamiento largo sin firmar() throw();

// Extractor

//

Operador const wchar_t* () const throw();

operador const char*() const throw(_com_error);

// Función auxiliar de bajo nivel

//

const wchar_t* GetWString() const throw();

const char* GetString() const

throw(_com_error);

Copia BSTR() const throw(_com_error);

void Assign(BSTR s) throw(_com_error

unsigned int); () const throw();

int Comparar(const Data_tamp; str) const throw();

privado:

wchar_t* m_wstr; >

mutable char* m_str;

unsigned long m_ RefCount;

// La construcción predeterminada nunca está permitida

//

Data_t() throw();

// Nunca se permite copiar

//

Data_t(const Data_tamp; s) throw(); p>

// Evitar la eliminación desde el exterior. Se debe utilizar Release().

//

~Data_t() tiro();

void _Free() tiro()

}; p>

p>

privado:

// Notación de recuento de referencias

//

Data_t* m_Data;

privado:

// Utilidades de bajo nivel

//

void _AddRef() throw()

void _Free( ) throw();

int _Compare(const _bstr_tamp; str) const throw();

}

Definición de _variant_t: COMUTIL.H

class _variant_t: public::tagVARIANT {

public:

// Constructor

//

p> _variant_t() throw ();

_variant_t(const VARIANTamp; varSrc) throw(_com_error);

_variant_t(const VARIANT* pSrc) throw(_com_ error);

_variant_t (const _variant_tamp; varSrc) throw(_com_error);

_variant_t(VARIANTamp; varSrc, bool fCopy) throw(_com_ error); // Adjunte VARIANT si! fCopy

_variant_t(sSrc corto, VARTYPE vtSrc = VT_I2) throw(_com_error); // Crea un VT_I2 o un VT_BOOL

_variant_t(long lSrc, VARTYPE vtSrc = VT_I4) throw(_com_error); // Crea VT_I4, VT_ERROR o VT_BOOL

_variant_t(float fltSrc) throw(); // Crea un VT_I2 o VT_BOOL

_variant_t(float fltSrc) throw(); _variant_t(float fltSrc) throw() // Crea un VT_R4

_variant_t(double dblSrc, VARTYPE vtSrc = VT_R8) throw(_com_error); // Crea un VT_R8, o un VT_DATE

_variant_t( const CYamp; cySrc) throw(); // Crea un VT_CY

_variant_t(const _bstr_tamp; bstrSrc) throw(_com_error); // Crea un VT_BSTR

_variante_t(const wchar_t *pSrc) throw(_com_error

); // Crea un VT_BSTR

_variant_t(const char* pSrc) throw(_com_error); // Crea un VT_ BSTR

_variant_t(IDispatch* pSrc, bool fAddRef = true) throw(); // Crea un VT_DISPATCH

_variant_t(bool bSrc) throw(); // Crea un VT_BOOL

_variant_t(IUnknown* pSrc, bool fAddRef = true) throw (); // Crea un VT_UNKNOWN

_variant_t(const DECIMALamp; decSrc) throw(); // Crea un VT_UNKNOWN

_variant_t(const DECIMALamp; decSrc) throw();/ / Crea un VT_DECIMAL

_variant_t(BYTE bSrc) throw(); // Crea un VT_UI1

// Destructor

//

~_variant_t() throw(_com_error);

// Función de extracción

//

operador short() const throw(_com_error);/ / Extraer short de VT_I2

operador long() constante throw(_com_error); // Extraer largo de VT_I4

operador float() constante throw(_com_error); // De VT_R4 Extraer float

CY

Operador _bstr_t() constante throw(_com_error); // Extraer _bstr_t de VT_BSTR

Operador IDispatch*( ) Lanzamientos constantes (_com_error); Extraer _bstr_t de VT_BSTR

Operador IDispatch*() Lanzamientos constantes (_com_error); // Extraer IDispatch* de VT_DISPATCH

Operador bool() constante throw(_com_error); de VT_BOOL

Operador IUnknown *() Constant throw(_com_error); // Extrae IUnknown* de VT_UNKNOWN

Operador DECIMAL() constante throw(_com_error); // Extrae DECIMAL de VT_DECIMAL;

Operador BYTE() constante throw(_com_error); // Extraer BTYE (sin firmar) del carácter VT_UI1)

// Operación de asignación

//

_variant_tamp; operador=(const VARIANTamp; varSrc) throw(_com_error);

_variant_tamp

; operador=(const VARIANT* pSrc) throw(_com_error);

_variant_tamp; operador=(const _variant_tamp; varSrc) throw(_com_error);

_variant_tamp; ) throw(_com_error); // Especifique VT_I2 o VT_BOOL

_variant_tamp; operator=(long lSrc) throw(_com_error); // Especifique VT_I4, VT _ERROR o VT_BOOL

_variant_tamp; operator=(float fltSrc) throw(_com_error); // Especifica VT_R4

_variant_tamp; operator=(double CY

_variant_tamp; operator=(const _bstr_tamp; bstrSrc) throw(_com_error) ; // Asigna un VT_BSTR

_variant_tamp; operator=(const wchar_t* pSrc) throw(_com_error); // Asigna un VT_BSTR

_variant_tamp; throw(_com_error); // Asignar un VT_BSTR

_variant_tamp; operator=(const char* pSrc) throw(_com_error); // Asignar un VT_BSTR

_variant_tamp; * pSrc) throw(_com_error); // Asignar un VT_DISPATCH

_variant_tamp; operator=(bool bSrc) throw( _com_error); // Asignar un VT_BOOL

_variant_tamp; IUnknown* pSrc) throw( _com_error); // Asignar un VT_UNKNOWN

_variant_tamp; operator=(const DECIMALamp; decSrc) throw( _com_error); // Asignar un VT_DECIMAL

_variant_tamp; operator=(BYTE bSrc) throw(_com_error); // Asignar un VT_UI1

// Operación de comparación

//

bool operator==(const VARIANTamp) ; varSrc) const throw(_com_error);

bool operador==(const VARIANT* pSrc) const throw(_com_error);

p>

operador bool! =(const VARIANTamp; varSrc) const throw(_com_error);

operador bool! =(const VARIANT* pSrc) const throw(_com_error);

// Operaciones de bajo nivel

//

void Clear() throw(_com_ error);

void Adjuntar(VARIANTamp; 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); // Se utiliza para configurar la cadena ANSI

};