Clase CComBSTR

Esta clase es un contenedor para BSTRs.

Sintaxis

class CComBSTR

Miembros

Constructores públicos

Nombre	Descripción
CComBSTR::CComBSTR	Constructor .
CComBSTR::~CComBSTR	El destructor .

Métodos públicos

Nombre	Descripción
CComBSTR::Append	Anexa una cadena a m_str.
CComBSTR::AppendBSTR	Anexa un BSTR a m_str.
CComBSTR::AppendBytes	Anexa un número especificado de bytes a m_str.
CComBSTR::ArrayToBSTR	Crea un BSTR a partir del primer carácter de cada elemento de safearray y lo adjunta al objeto CComBSTR.
CComBSTR::AssignBSTR	Asigna un objeto BSTR a m_str.
CComBSTR::Attach	Adjunta un elemento BSTR al objeto CComBSTR.
CComBSTR::BSTRToArray	Crea una caja segura unidimensional de base cero, donde cada elemento de la matriz es un carácter del objeto CComBSTR.
CComBSTR::ByteLength	Devuelve la longitud de m_str en bytes.
CComBSTR::Copy	Devuelve una copia de m_str.
CComBSTR::CopyTo	Devuelve una copia de m_str mediante un parámetro [out].
CComBSTR::Detach	Desasocia m_str del objeto CComBSTR.
CComBSTR::Empty	Libera m_str.
CComBSTR::Length	Devuelve la longitud de m_str.
CComBSTR::LoadString	Carga un recurso de cadena.
CComBSTR::ReadFromStream	Carga un objeto BSTR de una secuencia.
CComBSTR::ToLower	Convierte la cadena a minúsculas.
CComBSTR::ToUpper	Convierte la cadena a mayúsculas.
CComBSTR::WriteToStream	Guarda m_str en una secuencia.

Operadores públicos

Nombre	Descripción
CComBSTR::operator BSTR	Convierte un objeto CComBSTR en un BSTR.
CComBSTR::operator !	Devuelve TRUE o FALSE, en función de si m_str es null.
CComBSTR::operator !=	Compara un objeto CComBSTR con una cadena.
CComBSTR::operator &	Devuelve la dirección de m_str.
CComBSTR::operator +=	Anexa un CComBSTR al objeto.
CComBSTR::operator <	Compara un objeto CComBSTR con una cadena.
CComBSTR::operator =	Asigna un valor a m_str.
CComBSTR::operator ==	Compara un objeto CComBSTR con una cadena.
CComBSTR::operator >	Compara un objeto CComBSTR con una cadena.

Miembros de datos públicos

Nombre	Descripción
CComBSTR::m_str	Contiene el objeto BSTR asociado al objeto CComBSTR.

Comentarios

La clase CComBSTR es un contenedor para BSTR, que son cadenas con prefijo de longitud. La longitud se almacena como un entero en la ubicación de memoria que precede a los datos de la cadena.

Un objeto BSTR termina en null después del último carácter contado, pero también puede contener caracteres null insertados dentro de la cadena. La longitud de la cadena viene determinada por el recuento de caracteres, no por el primer carácter nulo.

Nota:

La clase CComBSTR proporciona una serie de miembros (constructores, operadores de asignación y operadores de comparación) que toman cadenas ANSI o Unicode como argumentos. Las versiones ANSI de estas funciones son menos eficaces que sus homólogos Unicode, ya que las cadenas Unicode temporales a menudo se crean internamente. Para mejorar la eficacia, use las versiones Unicode siempre que sea posible.

Nota:

Debido al comportamiento de búsqueda mejorado implementado en Visual Studio .NET, el código como bstr = L"String2" + bstr;, que puede haber compilado en versiones anteriores, debe implementarse como bstr = CStringW(L"String2") + bstr.

Para obtener una lista de precauciones al usar CComBSTR, consulte Programación con CComBSTR.

Requisitos

Encabezado: atlbase.h

CComBSTR::Append

Anexa lpsz o el miembro BSTR de bstrSrc a m_str.

HRESULT Append(const CComBSTR& bstrSrc) throw();
HRESULT Append(wchar_t ch) throw();
HRESULT Append(char ch) throw();
HRESULT Append(LPCOLESTR lpsz) throw();
HRESULT Append(LPCSTR lpsz) throw();
HRESULT Append(LPCOLESTR lpsz, int nLen) throw();

Parámetros

bstrSrc
[in] Objeto CComBSTR que se va a anexar.

ch
[in] Carácter que se va a anexar.

lpsz
[in] Cadena de caracteres terminada en cero que se va a anexar. Puede pasar una cadena Unicode a través de la sobrecarga LPCOLESTR o una cadena ANSI a través de la versión LPCSTR.

nLen
Número de caracteres de lpsz que se van a anexar.

Valor devuelto

S_OK si se ejecuta correctamente o cualquier valor de error estándar HRESULT.

Comentarios

Una cadena ANSI se convertirá en Unicode antes de anexarse.

Ejemplo

enum { urlASP, urlHTM, urlISAPI } urlType;
urlType = urlASP;

CComBSTR bstrURL = OLESTR("http://SomeSite/");
CComBSTR bstrDEF = OLESTR("/OtherSite");
CComBSTR bstrASP = OLESTR("default.asp");

CComBSTR bstrTemp;
HRESULT hr;

switch (urlType)
{
case urlASP:
   // bstrURL is 'http://SomeSite/default.asp'
   hr = bstrURL.Append(bstrASP);
   break;

case urlHTM:
   // bstrURL is 'http://SomeSite/default.htm'
   hr = bstrURL.Append(OLESTR("default.htm"));
   break;

case urlISAPI:
   // bstrURL is 'http://SomeSite/default.dll?func'
   hr = bstrURL.Append(OLESTR("default.dll?func"));
   break;

default:
   // bstrTemp is 'http://'
   hr = bstrTemp.Append(bstrURL, 7);
   // bstrURL is 'http://OtherSite'
   if (hr == S_OK)
       hr = bstrTemp.Append(bstrDEF);
   bstrURL = bstrTemp;

   break;
}

CComBSTR::AppendBSTR

Anexa el BSTR especificado a m_str.

HRESULT AppendBSTR(BSTR p) throw();

Parámetros

p
[in] BSTR que se va a anexar.

Valor devuelto

S_OK si se ejecuta correctamente o cualquier valor de error estándar HRESULT.

Comentarios

No pase una cadena de caracteres anchos normal a este método. El compilador no puede detectar el error y se producirán errores en tiempo de ejecución.

Ejemplo

CComBSTR bstrPre(OLESTR("Hello "));
CComBSTR bstrSuf(OLESTR("World!"));
HRESULT hr;

// Appends "World!" to "Hello "
hr = bstrPre.AppendBSTR(bstrSuf);

// Displays a message box with text "Hello World!"
::MessageBox(NULL, CW2CT(bstrPre), NULL, MB_OK);   

CComBSTR::AppendBytes

Anexa el número especificado de bytes a m_str sin conversión.

HRESULT AppendBytes(const char* lpsz, int nLen) throw();

Parámetros

lpsz
[in] Puntero a una matriz de bytes que se va a anexar.

p
[in] Número de bytes que se van a anexar.

Valor devuelto

S_OK si se ejecuta correctamente o cualquier valor de error estándar HRESULT.

Ejemplo

CComBSTR bstrPre(OLESTR("Hello "));
HRESULT hr;

// Appends "Wo" to "Hello " (4 bytes == 2 characters)
hr = bstrPre.AppendBytes(reinterpret_cast<char*>(OLESTR("World!")), 4);

// Displays a message box with text "Hello Wo"
::MessageBox(NULL, CW2CT(bstrPre), NULL, MB_OK);   

CComBSTR::ArrayToBSTR

Libera cualquier cadena existente que se mantenga en el objeto CComBSTR y, a continuación, crea un BSTR a partir del primer carácter de cada elemento de safearray y lo adjunta al objeto CComBSTR.

HRESULT ArrayToBSTR(const SAFEARRAY* pSrc) throw();

Parámetros

pSrc
[in] Safearray que contiene los elementos utilizados para crear la cadena.

Valor devuelto

S_OK si se ejecuta correctamente o cualquier valor de error estándar HRESULT.

CComBSTR::AssignBSTR

Asigna un objeto BSTR a m_str.

HRESULT AssignBSTR(const BSTR bstrSrc) throw();

Parámetros

bstrSrc
[in] BSTR que se va a asignar al objeto actual CComBSTR.

Valor devuelto

S_OK si se ejecuta correctamente o cualquier valor de error estándar HRESULT.

CComBSTR::Attach

Adjunta un objeto BSTR al objeto CComBSTR estableciendo el miembro m_str en src.

void Attach(BSTR src) throw();

Parámetros

src
[in] BSTR que se va a adjuntar al objeto .

Comentarios

No pase una cadena de caracteres anchos normal a este método. El compilador no puede detectar el error y se producirán errores en tiempo de ejecución.

Nota:

Este método afirmará si m_str no es null.

Ejemplo

// STDMETHOD(BSTRToUpper)(/*[in, out]*/ BSTR bstrConv);
STDMETHODIMP InplaceBSTRToUpper(BSTR bstrConv)
{
   // Assign bstrConv to m_str member of CComBSTR
   CComBSTR bstrTemp;
   bstrTemp.Attach(bstrConv); 

   // Make sure BSTR is not NULL string
   if (!bstrTemp)
        return E_POINTER;

   // Make string uppercase 
   HRESULT hr;
   hr = bstrTemp.ToUpper();
   if (hr != S_OK)
       return hr;

   // Set m_str to NULL, so the BSTR is not freed
   bstrTemp.Detach(); 

   return S_OK; 
}

CComBSTR::BSTRToArray

Crea una caja segura unidimensional de base cero, donde cada elemento de la matriz es un carácter del objeto CComBSTR.

HRESULT BSTRToArray(LPSAFEARRAY* ppArray) throw();

Parámetros

ppArray
[out] Puntero al objeto safearray usado para contener los resultados de la función.

Valor devuelto

S_OK si se ejecuta correctamente o cualquier valor de error estándar HRESULT.

CComBSTR::ByteLength

Devuelve el número de bytes en m_str, excluido el carácter null de terminación.

unsigned int ByteLength() const throw();

Valor devuelto

Longitud del miembro m_str en bytes.

Comentarios

Devuelve 0 si m_str es NULL.

Ejemplo

// string with 11 chars (22 bytes)
CComBSTR bstrTemp(OLESTR("Hello World"));

unsigned int len = bstrTemp.ByteLength();

ATLASSERT(len == 22);   

CComBSTR::CComBSTR

Constructor . El constructor predeterminado establece el miembro m_str en NULL.

CComBSTR() throw();
CComBSTR(const CComBSTR& src);
CComBSTR(REFGUID  guid);
CComBSTR(int nSize);
CComBSTR(int nSize, LPCOLESTR sz);
CComBSTR(int nSize, LPCSTR sz);
CComBSTR(LPCOLESTR pSrc);
CComBSTR(LPCSTR pSrc);
CComBSTR(CComBSTR&& src) throw(); // (Visual Studio 2017)

Parámetros

nSize
[in] El número de caracteres que se deben copiar de sz o el tamaño inicial en caracteres para CComBSTR.

sz
[in] Cadena que se va a copiar. La versión Unicode especifica un LPCOLESTR y la versión ANSI, un LPCSTR.

pSrc
[in] Cadena que se va a copiar. La versión Unicode especifica un LPCOLESTR y la versión ANSI, un LPCSTR.

src
[in] Objeto CComBSTR.

guid
[in] Referencia a una estructura GUID.

Comentarios

El constructor de copia establece m_str en una copia del miembro de src. El constructor REFGUID convierte el GUID en una cadena con StringFromGUID2 y almacena el resultado.

Los otros constructores establecen m_str en una copia de la cadena especificada. Si se pasa un valor para nSize, solo se copiarán nSize caracteres, seguidos de un carácter nulo.

CComBSTR admite la semántica de transferencia de recursos. Puede usar el constructor de movimiento (el constructor que toma una referencia de valor R (&&) para crear un objeto nuevo que utiliza los mismos datos subyacentes que el objeto antiguo que se pasa como argumento, sin la sobrecarga a la hora de copiar el objeto.

El destructor libera la cadena a la que apunta m_str.

Ejemplo

CComBSTR bstr1;   // BSTR points to NULL
bstr1 = "Bye";    // initialize with assignment operator
                  // ANSI string is converted to wide char

OLECHAR* str = OLESTR("Bye bye!");  // wide char string of length 5
int len = (int)wcslen(str);
CComBSTR bstr2(len + 1);// unintialized BSTR of length 6
wcsncpy_s(bstr2.m_str, bstr2.Length(), str, len); // copy wide char string to BSTR

CComBSTR bstr3(5, OLESTR("Hello World")); // BSTR containing 'Hello', 
                                          // input string is wide char
CComBSTR bstr4(5, "Hello World");         // same as above, input string 
                                          // is ANSI

CComBSTR bstr5(OLESTR("Hey there")); // BSTR containing 'Hey there', 
                                     // input string is wide char
CComBSTR bstr6("Hey there");         // same as above, input string 
                                     // is ANSI

CComBSTR bstr7(bstr6);     // copy constructor, bstr7 contains 'Hey there'   

CComBSTR::~CComBSTR

El destructor .

~CComBSTR();

Comentarios

El destructor libera la cadena a la que apunta m_str.

CComBSTR::Copy

Asigna y devuelve una copia de m_str.

BSTR Copy() const throw();

Valor devuelto

Copia del miembro m_str. Si m_str es NULL, devuelve NULL.

Ejemplo

CComBSTR m_bstrURL;    // BSTR representing a URL

// put_URL is the put method for the URL property. 
STDMETHOD(put_URL)(BSTR strURL)
{
    ATLTRACE(_T("put_URL\n"));

    // free existing string in m_bstrURL & make a copy 
    // of strURL pointed to by m_bstrURL
    m_bstrURL = strURL;
    return S_OK;
}

// get_URL is the get method for the URL property. 
STDMETHOD(get_URL)(BSTR* pstrURL)
{
    ATLTRACE(_T("get_URL\n"));

    // make a copy of m_bstrURL pointed to by pstrURL
    *pstrURL = m_bstrURL.Copy(); // See CComBSTR::CopyTo
    return S_OK;
}

CComBSTR::CopyTo

Asigna y devuelve una copia de m_str a través del parámetro.

HRESULT CopyTo(BSTR* pbstr) throw();

HRESULT CopyTo(VARIANT* pvarDest) throw();

Parámetros

pbstr
[out] Dirección de un objeto BSTR en el que se va a devolver la cadena asignada por este método.

pvarDest
[out] Dirección de un objeto VARIANT en el que se va a devolver la cadena asignada por este método.

Valor devuelto

Valor estándar HRESULT que indica el éxito o error de la copia.

Comentarios

Después de llamar a este método, el objeto VARIANT al que apunta el pvarDest será de tipo VT_BSTR.

Ejemplo

CComBSTR m_bstrURL; // BSTR representing a URL

// get_URL is the get method for the URL property. 
STDMETHOD(get_URL)(BSTR* pstrURL)
{
   // Make a copy of m_bstrURL and return it via pstrURL
   return m_bstrURL.CopyTo(pstrURL);
}

CComBSTR::Detach

Desasocia m_str del objeto CComBSTR y establece m_str en NULL.

BSTR Detach() throw();

Valor devuelto

Objeto BSTR asociado al objeto CComBSTR.

Ejemplo

// Method which converts bstrIn to uppercase 
STDMETHODIMP BSTRToUpper(BSTR bstrIn, BSTR* pbstrOut)
{ 
    if (bstrIn == NULL || pbstrOut == NULL) 
        return E_POINTER; 

    // Create a temporary copy of bstrIn
    CComBSTR bstrTemp(bstrIn); 

    if (!bstrTemp) 
        return E_OUTOFMEMORY; 

    // Make string uppercase
    HRESULT hr;
    hr = bstrTemp.ToUpper();
    if (hr != S_OK)
        return hr;
    
    // Return m_str member of bstrTemp 
    *pbstrOut = bstrTemp.Detach(); 

    return S_OK; 
}

CComBSTR::Empty

Libera el miembro m_str.

void Empty() throw();

Ejemplo

CComBSTR bstr(OLESTR("abc"));

// Calls SysFreeString to free the BSTR
bstr.Empty();
ATLASSERT(bstr.Length() == 0);   

CComBSTR::Length

Devuelve el número de caracteres de m_str, sin incluir el carácter nulo finalizado.

unsigned int Length() const throw();

Valor devuelto

Longitud del miembro m_str.

Ejemplo

// string with 11 chars
CComBSTR bstrTemp(OLESTR("Hello World"));

unsigned int len = bstrTemp.Length();

ATLASSERT(len == 11);

CComBSTR::LoadString

Carga un recurso de cadena especificado por nID y lo almacena en este objeto.

bool LoadString(HINSTANCE hInst, UINT nID) throw();
bool LoadString(UINT nID) throw();

Parámetros

Consulte el método LoadString de Windows SDK.

Valor devuelto

Devuelve TRUE si la cadena se carga correctamente; de lo contrario, devuelve FALSE.

Comentarios

La primera función carga el recurso del módulo identificado a través del parámetro hInst. La segunda función carga el recurso del módulo de recursos asociado al objeto CComModule derivado de que se usa en este proyecto.

Ejemplo

CComBSTR bstrTemp;

// IDS_PROJNAME proj name stored as resource in string table
bstrTemp.LoadString(IDS_PROJNAME);

// the above is equivalent to:
// bstrTemp.LoadString(_Module.m_hInstResource, IDS_PROJNAME);

// display message box w/ proj name as title & text
::MessageBox(NULL, CW2CT(bstrTemp), CW2CT(bstrTemp), MB_OK);   

CComBSTR::m_str

Contiene el objeto BSTR asociado al objeto CComBSTR.

BSTR m_str;

Ejemplo

CComBSTR GuidToBSTR(REFGUID guid) 
{
    // 39 - length of string representation of GUID + 1
    CComBSTR b(39); 

    // Convert GUID to BSTR
    // m_str member of CComBSTR is of type BSTR. When BSTR param 
    // is required, pass the m_str member explicitly or use implicit 
    // BSTR cast operator.
    int nRet = StringFromGUID2(guid, b.m_str, 39); 

    // Above equivalent to:
    // int nRet = StringFromGUID2(guid, b, 39); 
    // implicit BSTR cast operator used for 2nd param

    // Both lines are equivalent to:
    // CComBSTR b(guid);
    // CComBSTR constructor can convert GUIDs

    ATLASSERT(nRet); 
    return b; 
}

CComBSTR::operator BSTR

Convierte un objeto CComBSTR en un BSTR.

operator BSTR() const throw();

Comentarios

Permite pasar objetos CComBSTR a funciones que tienen parámetros [in] BSTR.

Ejemplo

Vea el ejemplo de CComBSTR::m_str.

CComBSTR::operator !

Comprueba si la cadena BSTR está NULL.

bool operator!() const throw();

Valor devuelto

Devuelve TRUE si el miembro m_str es NULL; en caso contrario, FALSE.

Comentarios

Este operador solo comprueba si hay un valor NULL, no para una cadena vacía.

Ejemplo

// STDMETHOD(BSTRToUpper)(/*[in, out]*/ BSTR bstrConv);
STDMETHODIMP InplaceBSTRToUpper(BSTR bstrConv)
{
   // Assign bstrConv to m_str member of CComBSTR
   CComBSTR bstrTemp;
   bstrTemp.Attach(bstrConv); 

   // Make sure BSTR is not NULL string
   if (!bstrTemp)
        return E_POINTER;

   // Make string uppercase 
   HRESULT hr;
   hr = bstrTemp.ToUpper();
   if (hr != S_OK)
       return hr;

   // Set m_str to NULL, so the BSTR is not freed
   bstrTemp.Detach(); 

   return S_OK; 
}

CComBSTR::operator !=

Devuelve el opuesto lógico de operator ==.

bool operator!= (const CComBSTR& bstrSrc) const throw();
bool operator!= (LPCOLESTR pszSrc) const;
bool operator!= (LPCSTR pszSrc) const;
bool operator!= (int nNull) const throw();

Parámetros

bstrSrc
[in] Objeto CComBSTR.

pszSrc
[in] Cadena terminada en cero.

nNull
[in] Debe ser null.

Valor devuelto

Devuelve TRUE si el elemento que se compara no es igual al objeto CComBSTR; de lo contrario, devuelve FALSE.

Comentarios

Los objetos CComBSTR se comparan textualmente en el contexto de la configuración regional predeterminada del usuario. El operador de comparación final simplemente compara la cadena contenida con NULL.

CComBSTR::operator &

Devuelve la dirección del objeto BSTR almacenado en el miembro m_str.

BSTR* operator&() throw();

Comentarios

CComBstr operator & tiene una aserción especial asociada para ayudar a identificar fugas de memoria. El programa se declarará cuando se inicialice el miembro m_str. Esta aserción se creó para identificar situaciones en las que un programador usa & operator para asignar un nuevo valor al miembro m_str sin liberar la primera asignación de m_str. Si m_str es igual a NULL, el programa supone que todavía no se asignó m_str. En este caso, el programa no se afirmará.

Esta aserción no está habilitada de forma predeterminada. Defina ATL_CCOMBSTR_ADDRESS_OF_ASSERT para habilitar esta aserción.

Ejemplo

#define ATL_NO_CCOMBSTR_ADDRESS_OF_ASSERT

void MyInitFunction(BSTR* pbstr)
{
   ::SysReAllocString(pbstr, OLESTR("Hello World"));
   return;
}

CComBSTR bstrStr ;
// bstrStr is not initialized so this call will not assert.
MyInitFunction(&bstrStr); 

CComBSTR bstrStr2(OLESTR("Hello World"));
// bstrStr2 is initialized so this call will assert.
::SysReAllocString(&bstrStr2, OLESTR("Bye"));

CComBSTR::operator +=

Anexa una cadena al objeto CComBSTR.

CComBSTR& operator+= (const CComBSTR& bstrSrc);
CComBSTR& operator+= (const LPCOLESTR pszSrc);

Parámetros

bstrSrc
[in] Objeto CComBSTR que se va a anexar.

pszSrc
[in] Cadena terminada en cero que se va a anexar.

Comentarios

Los objetos CComBSTR se comparan textualmente en el contexto de la configuración regional predeterminada del usuario. La comparación LPCOLESTR se realiza mediante memcmp en los datos sin procesar de cada cadena. La comparación LPCSTR se realiza de la misma manera una vez creada una copia Unicode temporal de pszSrc. El operador de comparación final simplemente compara la cadena contenida con NULL.

Ejemplo

CComBSTR bstrPre(OLESTR("Hello "));
CComBSTR bstrSuf(OLESTR("World!"));

// Appends "World!" to "Hello "
bstrPre += bstrSuf;

// Displays a message box with text "Hello World!"
::MessageBox(NULL, CW2CT(bstrPre), NULL, MB_OK);   

CComBSTR::operator <

Compara un objeto CComBSTR con una cadena.

bool operator<(const CComBSTR& bstrSrc) const throw();
bool operator<(LPCOLESTR pszSrc) const throw();
bool operator<(LPCSTR pszSrc) const throw();

Valor devuelto

Devuelve TRUE si el elemento que se va a comparar es menor que el objeto CComBSTR; de lo contrario, devuelve FALSE.

Comentarios

La comparación se realiza mediante la configuración regional predeterminada del usuario.

CComBSTR::operator =

Establece el miembro m_str en una copia de pSrc o en una copia del miembro BSTR de src. El operador de asignación de movimiento se mueve src sin copiarlo.

CComBSTR& operator= (const CComBSTR& src);
CComBSTR& operator= (LPCOLESTR pSrc);
CComBSTR& operator= (LPCSTR pSrc);
CComBSTR& operator= (CComBSTR&& src) throw(); // (Visual Studio 2017)

Comentarios

El parámetro pSrc especifica un objeto LPCOLESTR para las versiones Unicode o LPCSTR para las versiones ANSI.

Ejemplo

Vea el ejemplo de CComBSTR::Copy.

CComBSTR::operator ==

Compara un objeto CComBSTR con una cadena. Los objetos CComBSTR se comparan textualmente en el contexto de la configuración regional predeterminada del usuario.

bool operator== (const CComBSTR& bstrSrc) const throw();
bool operator== (LPCOLESTR pszSrc) const;
bool operator== (LPCSTR pszSrc) const;
bool operator== (int nNull) const throw();

Parámetros

bstrSrc
[in] Objeto CComBSTR.

pszSrc
[in] Cadena terminada en cero.

nNull
[in] Debe ser NULL.

Valor devuelto

Devuelve TRUE si el elemento que se va a comparar es igual al objeto CComBSTR; de lo contrario, devuelve FALSE.

Comentarios

El operador de comparación final simplemente compara la cadena contenida con NULL.

CComBSTR::operator >

Compara un objeto CComBSTR con una cadena.

bool operator>(const CComBSTR& bstrSrc) const throw();

Valor devuelto

Devuelve TRUE si el elemento que se va a comparar es mayor que el objeto CComBSTR; de lo contrario, devuelve FALSE.

Comentarios

La comparación se realiza mediante la configuración regional predeterminada del usuario.

CComBSTR::ReadFromStream

Establece el miembro m_str en el BSTR contenido de la secuencia especificada.

HRESULT ReadFromStream(IStream* pStream) throw();

Parámetros

pStream
[in] Puntero a la interfaz IStream de la secuencia que contiene los datos.

Valor devuelto

Un valor HRESULT estándar.

Comentarios

ReadToStream requiere que el contenido de la secuencia en la posición actual sea compatible con el formato de datos escrito por una llamada a WriteToStream.

Ejemplo

IDataObject* pDataObj;

// Fill in the FORMATETC struct to retrieve desired format 
// from clipboard
FORMATETC formatetcIn = {CF_TEXT, NULL, DVASPECT_CONTENT, -1, TYMED_ISTREAM};
STGMEDIUM medium;
ZeroMemory(&medium, sizeof(STGMEDIUM));

// Get IDataObject from clipboard
HRESULT hr = ::OleGetClipboard(&pDataObj);

// Retrieve data from clipboard
hr = pDataObj->GetData(&formatetcIn, &medium);

if (SUCCEEDED(hr) && medium.tymed == TYMED_ISTREAM)
{
   CComBSTR bstrStr;
   // Get BSTR out of the stream
   hr = bstrStr.ReadFromStream(medium.pstm);

   //release the stream
   ::ReleaseStgMedium(&medium);
}

CComBSTR::ToLower

Cambia la cadena especificada a minúsculas.

HRESULT ToLower() throw();

Valor devuelto

Un valor HRESULT estándar.

Comentarios

Consulte CharLowerBuff para obtener más información sobre cómo se realiza la conversión.

CComBSTR::ToUpper

Convierte la cadena contenida en mayúsculas.

HRESULT ToUpper() throw();

Valor devuelto

Un valor HRESULT estándar.

Comentarios

Consulte CharUpperBuff para obtener más información sobre cómo se realiza la conversión.

CComBSTR::WriteToStream

Guarda el miembro m_str en una secuencia.

HRESULT WriteToStream(IStream* pStream) throw();

Parámetros

pStream
[in] Puntero a la interfaz IStream de una secuencia.

Valor devuelto

Un valor HRESULT estándar.

Comentarios

Puede volver a crear un BSTR a partir del contenido de la secuencia mediante la función ReadFromStream.

Ejemplo

//implementation of IDataObject::GetData()
STDMETHODIMP CMyDataObj::GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
{
    HRESULT hr = S_OK;
    if (pformatetcIn->cfFormat == CF_TEXT && pformatetcIn->tymed == TYMED_ISTREAM)
    {
        IStream *pStm;
        // Create an IStream from global memory
        hr = CreateStreamOnHGlobal(NULL, TRUE, &pStm);
        if (FAILED(hr))
            return hr;

        // Initialize CComBSTR
        CComBSTR bstrStr = OLESTR("Hello World");

        // Serialize string into stream
        // the length followed by actual string is serialized into stream
        hr = bstrStr.WriteToStream(pStm);

        // Pass the IStream pointer back through STGMEDIUM struct
        pmedium->tymed = TYMED_ISTREAM;
        pmedium->pstm = pStm;
        pmedium->pUnkForRelease = NULL; 
    }

    return hr;
}

Vea también

Información general sobre la clase
Macros de conversión de cadenas ATL y MFC