Classe CComBSTR

Questa classe è un wrapper per BSTRs.

Sintassi

class CComBSTR

Membri

Costruttori pubblici

Nome	Descrizione
CComBSTR::CComBSTR	Costruttore.
CComBSTR::~CComBSTR	Distruttore.

Metodi pubblici

Nome	Descrizione
CComBSTR::Append	Aggiunge una stringa a m_str.
CComBSTR::AppendBSTR	Aggiunge un oggetto BSTR a m_str.
CComBSTR::AppendBytes	Aggiunge un numero specificato di byte a m_str.
CComBSTR::ArrayToBSTR	Crea un oggetto BSTR dal primo carattere di ogni elemento nell'oggetto safearray e lo associa all'oggetto CComBSTR .
CComBSTR::AssignBSTR	Assegna un oggetto BSTR a m_str.
CComBSTR::Attach	Associa un oggetto BSTR all'oggetto CComBSTR .
CComBSTR::BSTRToArray	Crea un safearray unidimensionale in base zero, in cui ogni elemento della matrice è un carattere dell'oggetto CComBSTR .
CComBSTR::ByteLength	Restituisce la lunghezza di m_str in byte.
CComBSTR::Copy	Restituisce una copia di m_str.
CComBSTR::CopyTo	Restituisce una copia di m_str tramite un [out] parametro
CComBSTR::Detach	m_str Scollega dall'oggetto CComBSTR .
CComBSTR::Empty	m_strLibera .
CComBSTR::Length	Restituisce la lunghezza di m_str.
CComBSTR::LoadString	Carica una risorsa stringa.
CComBSTR::ReadFromStream	Carica un BSTR oggetto da un flusso.
CComBSTR::ToLower	Converte la stringa in lettere minuscole.
CComBSTR::ToUpper	Converte la stringa in maiuscolo.
CComBSTR::WriteToStream	Salva m_str in un flusso.

Operatori pubblici

Nome	Descrizione
CComBSTR::operator BSTR	Esegue il cast di un CComBSTR oggetto a un oggetto BSTR.
CComBSTR::operator !	Restituisce TRUE o FALSE, a seconda che m_str sia NULL.
CComBSTR::operator !=	Confronta un oggetto CComBSTR con una stringa.
CComBSTR::operator &	Restituisce l'indirizzo di m_str.
CComBSTR::operator +=	Aggiunge un oggetto CComBSTR all'oggetto .
CComBSTR::operator <	Confronta un oggetto CComBSTR con una stringa.
CComBSTR::operator =	Assegna un valore a m_str.
CComBSTR::operator ==	Confronta un oggetto CComBSTR con una stringa.
CComBSTR::operator >	Confronta un oggetto CComBSTR con una stringa.

Membri dati pubblici

Nome	Descrizione
CComBSTR::m_str	Contiene l'oggetto BSTR associato all'oggetto CComBSTR .

Osservazioni:

La CComBSTR classe è un wrapper per BSTRs, ovvero stringhe con prefisso di lunghezza. La lunghezza viene archiviata come numero intero nella posizione di memoria che precede i dati nella stringa.

Un BSTR oggetto viene terminato con null dopo l'ultimo carattere contato, ma può contenere anche caratteri Null incorporati all'interno della stringa. La lunghezza della stringa è determinata dal conteggio dei caratteri, non dal primo carattere Null.

Per un elenco di avvertenze quando si usa CComBSTR, vedere Programmazione con CComBSTR.

Requisiti

Intestazione: atlbase.h

CComBSTR::Append

lpsz Aggiunge o il membro BSTR di 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();

Parametri

bstrSrc
[in] Oggetto CComBSTR da accodare.

ch
[in] Carattere da accodare.

lpsz
[in] Stringa di caratteri con terminazione zero da aggiungere. È possibile passare una stringa Unicode tramite l'overload LPCOLESTR o una stringa ANSI tramite la LPCSTR versione.

nLen
[in] Numero di caratteri da lpsz aggiungere.

Valore restituito

S_OK in caso di esito positivo o di qualsiasi valore di errore standard HRESULT .

Osservazioni:

Una stringa ANSI verrà convertita in Unicode prima di essere accodata.

Esempio

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

Accoda l'oggetto specificato BSTR a m_str.

HRESULT AppendBSTR(BSTR p) throw();

Parametri

p
[in] Oggetto BSTR da accodare.

Valore restituito

S_OK in caso di esito positivo o di qualsiasi valore di errore standard HRESULT .

Osservazioni:

Non passare una normale stringa di caratteri wide a questo metodo. Il compilatore non riesce a rilevare l'errore e si verificheranno errori di runtime.

Esempio

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

Aggiunge il numero specificato di byte a m_str senza conversione.

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

Parametri

lpsz
[in] Puntatore a una matrice di byte da aggiungere.

p
[in] Numero di byte da aggiungere.

Valore restituito

S_OK in caso di esito positivo o di qualsiasi valore di errore standard HRESULT .

Esempio

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 qualsiasi stringa esistente contenuta nell'oggetto CComBSTR , quindi crea un BSTR oggetto dal primo carattere di ogni elemento nell'oggetto safearray e lo collega all'oggetto CComBSTR .

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

Parametri

pSrc
[in] Safearray contenente gli elementi utilizzati per creare la stringa.

Valore restituito

S_OK in caso di esito positivo o di qualsiasi valore di errore standard HRESULT .

CComBSTR::AssignBSTR

Assegna un oggetto BSTR a m_str.

HRESULT AssignBSTR(const BSTR bstrSrc) throw();

Parametri

bstrSrc
[in] BSTR da assegnare all'oggetto corrente CComBSTR .

Valore restituito

S_OK in caso di esito positivo o di qualsiasi valore di errore standard HRESULT .

CComBSTR::Attach

Associa un oggetto all'oggetto CComBSTR impostando il m_str membro su src.BSTR

void Attach(BSTR src) throw();

Parametri

src
[in] Oggetto BSTR da associare all'oggetto .

Osservazioni:

Non passare una normale stringa di caratteri wide a questo metodo. Il compilatore non riesce a rilevare l'errore e si verificheranno errori di runtime.

Esempio

// 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 un safearray unidimensionale in base zero, in cui ogni elemento della matrice è un carattere dell'oggetto CComBSTR .

HRESULT BSTRToArray(LPSAFEARRAY* ppArray) throw();

Parametri

ppArray
[out] Puntatore all'oggetto safearray usato per contenere i risultati della funzione.

Valore restituito

S_OK in caso di esito positivo o di qualsiasi valore di errore standard HRESULT .

CComBSTR::ByteLength

Restituisce il numero di byte in m_str, escluso il carattere Null di terminazione.

unsigned int ByteLength() const throw();

Valore restituito

Lunghezza del m_str membro in byte.

Osservazioni:

Restituisce 0 se m_str è NULL.

Esempio

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

unsigned int len = bstrTemp.ByteLength();

ATLASSERT(len == 22);   

CComBSTR::CComBSTR

Costruttore. Il costruttore predefinito imposta il m_str membro su 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)

Parametri

nSize
[in] Numero di caratteri da copiare da sz o la dimensione iniziale in caratteri per l'oggetto CComBSTR.

sz
[in] Stringa da copiare. La versione Unicode specifica un oggetto LPCOLESTR. La versione ANSI specifica un LPCSTR.

pSrc
[in] Stringa da copiare. La versione Unicode specifica un oggetto LPCOLESTR. La versione ANSI specifica un LPCSTR.

src
[in] Oggetto CComBSTR.

guid
[in] Riferimento a una GUID struttura.

Osservazioni:

Il costruttore di copia imposta m_str su una copia del membro BSTR di src. Il REFGUID costruttore converte il GUID in una stringa utilizzando StringFromGUID2 e archivia il risultato.

L'altro costruttore imposta m_str su una copia della stringa specificata. Se si passa un valore per nSize, verranno copiati solo nSize i caratteri, seguiti da un carattere Null di terminazione.

CComBSTR supporta la semantica di spostamento. È possibile usare il costruttore di spostamento (il costruttore che accetta un riferimento rvalue (&&) per creare un nuovo oggetto che usa gli stessi dati sottostanti dell'oggetto precedente passato come argomento, senza il sovraccarico di copiare l'oggetto.

Il distruttore libera la stringa a cui punta m_str.

Esempio

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

Distruttore.

~CComBSTR();

Osservazioni:

Il distruttore libera la stringa a cui punta m_str.

CComBSTR::Copy

Alloca e restituisce una copia di m_str.

BSTR Copy() const throw();

Valore restituito

Copia del m_str membro. Se m_str è NULL, restituisce NULL.

Esempio

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

Alloca e restituisce una copia di m_str tramite il parametro .

HRESULT CopyTo(BSTR* pbstr) throw();

HRESULT CopyTo(VARIANT* pvarDest) throw();

Parametri

pbstr
[out] Indirizzo di un oggetto BSTR in cui restituire la stringa allocata da questo metodo.

pvarDest
[out] Indirizzo di un oggetto VARIANT in cui restituire la stringa allocata da questo metodo.

Valore restituito

Valore standard HRESULT che indica l'esito positivo o negativo della copia.

Osservazioni:

Dopo aver chiamato questo metodo, l'oggetto VARIANT a cui pvarDest punta sarà di tipo VT_BSTR.

Esempio

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

m_str Scollega dall'oggetto CComBSTR e imposta m_str su NULL.

BSTR Detach() throw();

Valore restituito

Oggetto BSTR associato all'oggetto CComBSTR.

Esempio

// 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 il m_str membro.

void Empty() throw();

Esempio

CComBSTR bstr(OLESTR("abc"));

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

CComBSTR::Length

Restituisce il numero di caratteri in m_str, escluso il carattere Null di terminazione.

unsigned int Length() const throw();

Valore restituito

Lunghezza del m_str membro.

Esempio

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

unsigned int len = bstrTemp.Length();

ATLASSERT(len == 11);

CComBSTR::LoadString

Carica una risorsa stringa specificata da nID e la archivia in questo oggetto.

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

Parametri

Vedere LoadString in Windows SDK.

Valore restituito

Restituisce TRUE se la stringa viene caricata correttamente; in caso contrario, restituisce FALSE.

Osservazioni:

La prima funzione carica la risorsa dal modulo identificato dall'utente tramite il hInst parametro . La seconda funzione carica la risorsa dal modulo di risorse associato all'oggetto CComModulederivato da usato in questo progetto.

Esempio

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 l'oggetto BSTR associato all'oggetto CComBSTR .

BSTR m_str;

Esempio

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

Esegue il cast di un CComBSTR oggetto a un oggetto BSTR.

operator BSTR() const throw();

Osservazioni:

Consente di passare CComBSTR oggetti a funzioni con parametri [in]. BSTR

Esempio

Vedere l'esempio per CComBSTR::m_str.

CComBSTR::operator !

Controlla se BSTR la stringa è NULL.

bool operator!() const throw();

Valore restituito

Restituisce TRUE se il m_str membro è NULL; in caso contrario, FALSE.

Osservazioni:

Questo operatore controlla solo la presenza di un NULL valore, non di una stringa vuota.

Esempio

// 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 !=

Restituisce l'opposto logico di operator ==.

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

Parametri

bstrSrc
[in] Oggetto CComBSTR.

pszSrc
[in] Stringa con terminazione zero.

nNull
[in] Deve essere NULL.

Valore restituito

Restituisce TRUE se l'elemento confrontato non è uguale all'oggetto CComBSTR ; in caso contrario, restituisce FALSE.

Osservazioni:

CComBSTRs vengono confrontati in modo testuale nel contesto delle impostazioni locali predefinite dell'utente. L'operatore di confronto finale confronta semplicemente la stringa contenuta con NULL.

CComBSTR::operator &

Restituisce l'indirizzo dell'oggetto BSTR archiviato nel m_str membro.

BSTR* operator&() throw();

Osservazioni:

CComBstr operator & dispone di un'asserzione speciale associata a tale asserzione per identificare le perdite di memoria. Il programma asserisce quando il m_str membro viene inizializzato. Questa asserzione è stata creata per identificare le situazioni in cui un programmatore usa per & operator assegnare un nuovo valore al m_str membro senza liberare la prima allocazione di m_str. Se m_str è uguale NULLa , il programma presuppone che m_str non sia ancora stato allocato. In questo caso, il programma non asserisce.

Questa asserzione non è abilitata per impostazione predefinita. Definire ATL_CCOMBSTR_ADDRESS_OF_ASSERT per abilitare questa asserzione.

Esempio

#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 +=

Aggiunge una stringa all'oggetto CComBSTR .

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

Parametri

bstrSrc
[in] Oggetto CComBSTR da accodare.

pszSrc
[in] Stringa con terminazione zero da aggiungere.

Osservazioni:

CComBSTRs vengono confrontati in modo testuale nel contesto delle impostazioni locali predefinite dell'utente. Il LPCOLESTR confronto viene eseguito usando memcmp i dati non elaborati in ogni stringa. Il LPCSTR confronto viene eseguito nello stesso modo dopo la creazione di una copia Unicode temporanea di pszSrc . L'operatore di confronto finale confronta semplicemente la stringa contenuta con NULL.

Esempio

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 <

Confronta un oggetto CComBSTR con una stringa.

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

Valore restituito

Restituisce TRUE se l'elemento confrontato è minore dell'oggetto CComBSTR ; in caso contrario, restituisce FALSE.

Osservazioni:

Il confronto viene eseguito usando le impostazioni locali predefinite dell'utente.

CComBSTR::operator =

Imposta il m_str membro su una copia di pSrc o su una copia del BSTR membro di src. L'operatore di assegnazione di spostamento viene spostato src senza copiarlo.

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

Osservazioni:

Il pSrc parametro specifica un oggetto LPCOLESTR per le versioni Unicode o LPCSTR per le versioni ANSI.

Esempio

Vedere l'esempio per CComBSTR::Copy.

CComBSTR::operator ==

Confronta un oggetto CComBSTR con una stringa. CComBSTRs vengono confrontati in modo testuale nel contesto delle impostazioni locali predefinite dell'utente.

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

Parametri

bstrSrc
[in] Oggetto CComBSTR.

pszSrc
[in] Stringa con terminazione zero.

nNull
[in] Deve essere NULL.

Valore restituito

Restituisce TRUE se l'elemento confrontato è uguale all'oggetto CComBSTR ; in caso contrario, restituisce FALSE.

Osservazioni:

L'operatore di confronto finale confronta semplicemente la stringa contenuta con NULL.

CComBSTR::operator >

Confronta un oggetto CComBSTR con una stringa.

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

Valore restituito

Restituisce TRUE se l'elemento confrontato è maggiore dell'oggetto CComBSTR ; in caso contrario, restituisce FALSE.

Osservazioni:

Il confronto viene eseguito usando le impostazioni locali predefinite dell'utente.

CComBSTR::ReadFromStream

Imposta il m_str membro sull'oggetto BSTR contenuto nel flusso specificato.

HRESULT ReadFromStream(IStream* pStream) throw();

Parametri

pStream
[in] Puntatore all'interfaccia IStream nel flusso contenente i dati.

Valore restituito

Un valore HRESULT standard.

Osservazioni:

ReadToStream richiede che il contenuto del flusso nella posizione corrente sia compatibile con il formato di dati scritto da una chiamata a WriteToStream.

Esempio

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

Converte la stringa contenuta in lettere minuscole.

HRESULT ToLower() throw();

Valore restituito

Un valore HRESULT standard.

Osservazioni:

Per altre informazioni sull'esecuzione della conversione, vedere CharLowerBuff .

CComBSTR::ToUpper

Converte la stringa contenuta in maiuscolo.

HRESULT ToUpper() throw();

Valore restituito

Un valore HRESULT standard.

Osservazioni:

Per altre informazioni sull'esecuzione della conversione, vedere CharUpperBuff .

CComBSTR::WriteToStream

Salva il m_str membro in un flusso.

HRESULT WriteToStream(IStream* pStream) throw();

Parametri

pStream
[in] Puntatore all'interfaccia IStream in un flusso.

Valore restituito

Un valore HRESULT standard.

Osservazioni:

È possibile ricreare un oggetto BSTR dal contenuto del flusso usando la ReadFromStream funzione .

Esempio

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

Vedi anche

Cenni preliminari sulla classe
Macro di conversione di stringhe ATL e MFC