CComBSTR-Klasse

Diese Klasse ist ein Wrapper für BSTRs.

Syntax

class CComBSTR

Member

Öffentliche Konstruktoren

Name	Beschreibung
CComBSTR::CComBSTR	Der Konstruktor.
CComBSTR::~CComBSTR	Der Destruktor.

Öffentliche Methoden

Name	Beschreibung
CComBSTR::Append	Fügt eine Zeichenfolge an m_str.
CComBSTR::AppendBSTR	Fügt eine BSTR an m_str.
CComBSTR::AppendBytes	Fügt eine angegebene Anzahl von Bytes an m_str.
CComBSTR::ArrayToBSTR	Erstellt ein aus BSTR dem ersten Zeichen jedes Elements im Safearray und fügt es an das CComBSTR Objekt an.
CComBSTR::AssignBSTR	Weist eine BSTR zu m_str.
CComBSTR::Attach	Fügt ein Objekt BSTR CComBSTR an.
CComBSTR::BSTRToArray	Erstellt ein nullbasiertes eindimensionales Safearray, wobei jedes Element des Arrays ein Zeichen aus dem CComBSTR Objekt ist.
CComBSTR::ByteLength	Gibt die Länge in m_str Byte zurück.
CComBSTR::Copy	Gibt eine Kopie von m_str.
CComBSTR::CopyTo	Gibt eine Kopie eines m_str Parameters zurück [out] .
CComBSTR::Detach	Trennt m_str vom CComBSTR Objekt.
CComBSTR::Empty	Frei.m_str
CComBSTR::Length	Gibt die Länge von m_str.
CComBSTR::LoadString	Lädt eine Zeichenfolgenressource.
CComBSTR::ReadFromStream	Lädt ein BSTR Objekt aus einem Datenstrom.
CComBSTR::ToLower	Konvertiert die Zeichenfolge in Kleinbuchstaben.
CComBSTR::ToUpper	Konvertiert die Zeichenfolge in Großbuchstaben.
CComBSTR::WriteToStream	Speichert m_str in einem Datenstrom.

Öffentliche Operatoren

Name	Beschreibung
CComBSTR::operator BSTR	Wandelt ein CComBSTR Objekt in einen BSTR um.
CComBSTR::operator !	Gibt WAHR oder FALSCH zurück, je nachdem, ob m_str NULL ist.
CComBSTR::operator !=	Vergleicht eine CComBSTR mit einer Zeichenfolge.
CComBSTR::operator &	Gibt die Adresse von m_str.
CComBSTR::operator +=	Fügt ein CComBSTR Objekt an.
CComBSTR::operator <	Vergleicht eine CComBSTR mit einer Zeichenfolge.
CComBSTR::operator =	Weist einen Wert zu m_str.
CComBSTR::operator ==	Vergleicht eine CComBSTR mit einer Zeichenfolge.
CComBSTR::operator >	Vergleicht eine CComBSTR mit einer Zeichenfolge.

Öffentliche Datenmember

Name	Beschreibung
CComBSTR::m_str	Enthält das BSTR zugeordnete CComBSTR Objekt.

Hinweise

Die CComBSTR Klasse ist ein Wrapper für BSTRs, bei dem es sich um längenpräfixierte Zeichenfolgen handelt. Die Länge wird als ganze Zahl an der Speicherposition gespeichert, die den Daten in der Zeichenfolge vorausgeht.

A BSTR wird nach dem letzten gezählten Zeichen null beendet, kann aber auch NULL-Zeichen enthalten, die in die Zeichenfolge eingebettet sind. Die Zeichenfolgenlänge wird durch die Zeichenanzahl bestimmt, nicht durch das erste NULL-Zeichen.

Eine Liste der Vorsichtsmaßnahmen bei der Verwendung CComBSTRfinden Sie unter Programmieren mit CComBSTR.

Anforderungen

Header: atlbase.h

CComBSTR::Append

Fügt entweder lpsz oder das BSTR-Element von bstrSrc an 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();

Parameter

bstrSrc
[in] Ein CComBSTR anzufügende Objekt.

ch
[in] Ein anzufügende Zeichen.

lpsz
[in] Eine anzufügende Null-Zeichenfolge. Sie können eine Unicode-Zeichenfolge über die LPCOLESTR Überladung oder eine ANSI-Zeichenfolge über die LPCSTR Version übergeben.

nLen
[in] Die Anzahl der anzufügenden Zeichen lpsz .

Rückgabewert

S_OK bei Erfolg oder einem Standardfehlerwert HRESULT .

Hinweise

Eine ANSI-Zeichenfolge wird vor dem Anfügen in Unicode konvertiert.

Beispiel

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

Fügt das angegebene BSTR Anfügen an m_str.

HRESULT AppendBSTR(BSTR p) throw();

Parameter

p
[in] A BSTR , das angefügt werden soll.

Rückgabewert

S_OK bei Erfolg oder einem Standardfehlerwert HRESULT .

Hinweise

Übergeben Sie keine normale Breite-Zeichenfolge an diese Methode. Der Compiler kann den Fehler nicht abfangen, und Laufzeitfehler treten auf.

Beispiel

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

Fügt die angegebene Anzahl von Bytes ohne Konvertierung an m_str .

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

Parameter

lpsz
[in] Ein Zeiger auf ein anzufügende Bytearray.

p
[in] Die Anzahl der anzufügenden Bytes.

Rückgabewert

S_OK bei Erfolg oder einem Standardfehlerwert HRESULT .

Beispiel

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

Gibt eine vorhandene Zeichenfolge frei, die CComBSTR im Objekt gespeichert ist, erstellt dann ein aus BSTR dem ersten Zeichen jedes Elements im Safearray und fügt sie an das CComBSTR Objekt an.

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

Parameter

pSrc
[in] Das Safearray, das die Zum Erstellen der Zeichenfolge verwendeten Elemente enthält.

Rückgabewert

S_OK bei Erfolg oder einem Standardfehlerwert HRESULT .

CComBSTR::AssignBSTR

Weist eine BSTR zu m_str.

HRESULT AssignBSTR(const BSTR bstrSrc) throw();

Parameter

bstrSrc
[in] Ein BSTR, der dem aktuellen CComBSTR Objekt zugewiesen werden soll.

Rückgabewert

S_OK bei Erfolg oder einem Standardfehlerwert HRESULT .

CComBSTR::Attach

Fügt ein Objekt BSTR an, CComBSTR indem das m_str Element auf src.

void Attach(BSTR src) throw();

Parameter

src
[in] Der BSTR an das Objekt angefügte Wert.

Hinweise

Übergeben Sie keine normale Breite-Zeichenfolge an diese Methode. Der Compiler kann den Fehler nicht abfangen, und Laufzeitfehler treten auf.

Beispiel

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

Erstellt ein nullbasiertes eindimensionales Safearray, wobei jedes Element des Arrays ein Zeichen aus dem CComBSTR Objekt ist.

HRESULT BSTRToArray(LPSAFEARRAY* ppArray) throw();

Parameter

ppArray
[out] Der Zeiger auf das Safearray, das zum Halten der Ergebnisse der Funktion verwendet wird.

Rückgabewert

S_OK bei Erfolg oder einem Standardfehlerwert HRESULT .

CComBSTR::ByteLength

Gibt die Anzahl der Bytes in m_str, mit Ausnahme des endenden Nullzeichens, zurück.

unsigned int ByteLength() const throw();

Rückgabewert

Die Länge des m_str Elements in Byte.

Hinweise

Gibt 0 zurück, wenn m_str dies der Wert ist NULL.

Beispiel

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

unsigned int len = bstrTemp.ByteLength();

ATLASSERT(len == 22);   

CComBSTR::CComBSTR

Der Konstruktor. Der Standardkonstruktor legt das m_str Element auf 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)

Parameter

nSize
[in] Die Anzahl der Zeichen, die kopiert sz werden sollen, oder die Anfangsgröße in Zeichen für das CComBSTRZeichen.

sz
[in] Eine zu kopierende Zeichenfolge. Die Unicode-Version gibt eine LPCOLESTR; die ANSI-Version gibt einen LPCSTR an.

pSrc
[in] Eine zu kopierende Zeichenfolge. Die Unicode-Version gibt eine LPCOLESTR; die ANSI-Version gibt einen LPCSTR an.

src
[in] Ein CComBSTR-Objekt.

guid
[in] Ein Verweis auf eine GUID Struktur.

Hinweise

Der Kopierkonstruktor wird m_str auf eine Kopie des BSTR-Elements von src. Der REFGUID Konstruktor konvertiert die GUID in eine Zeichenfolge und StringFromGUID2 speichert das Ergebnis.

Die anderen Konstruktoren legen m_str auf eine Kopie der angegebenen Zeichenfolge fest. Wenn Sie einen Wert für nSizeübergeben, werden nur nSize Zeichen kopiert, gefolgt von einem endenden Nullzeichen.

CComBSTR unterstützt die move-Semantik. Mit dem Bewegungskonstruktor (dem Konstruktor, der einen rvalue-Verweis verwendet (&&) können Sie ein neues Objekt erstellen, das die Daten des alten als Argument übergebenen Objekts verwendet, ohne das Objekt kopieren zu müssen.

Der Destruktor gibt die Zeichenfolge frei, auf die von m_str gezeigt wird.

Beispiel

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

Der Destruktor.

~CComBSTR();

Hinweise

Der Destruktor gibt die Zeichenfolge frei, auf die von m_str gezeigt wird.

CComBSTR::Copy

Weist eine Kopie von m_str.

BSTR Copy() const throw();

Rückgabewert

Eine Kopie des m_str Mitglieds. Wenn m_str gleich NULL ist, wird NULL zurückgegeben.

Beispiel

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

Weist eine Kopie des m_str Parameters zu und gibt sie zurück.

HRESULT CopyTo(BSTR* pbstr) throw();

HRESULT CopyTo(VARIANT* pvarDest) throw();

Parameter

pbstr
[out] Die Adresse einer BSTR , in der die von dieser Methode zugewiesene Zeichenfolge zurückgegeben werden soll.

pvarDest
[out] Die Adresse einer VARIANT , in der die von dieser Methode zugewiesene Zeichenfolge zurückgegeben werden soll.

Rückgabewert

Ein Standardwert HRESULT , der den Erfolg oder Fehler der Kopie angibt.

Hinweise

Nach dem Aufrufen dieser Methode ist der VARIANT Punkt pvarDest vom Typ VT_BSTR.

Beispiel

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

Trennt m_str vom Objekt und legt diesen m_str wert fest auf NULLCComBSTR .

BSTR Detach() throw();

Rückgabewert

Der BSTR, der dem CComBSTR-Objekt zugeordnet ist.

Beispiel

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

Gibt das Mitglied frei m_str .

void Empty() throw();

Beispiel

CComBSTR bstr(OLESTR("abc"));

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

CComBSTR::Length

Gibt die Anzahl der Zeichen in m_str, mit Ausnahme des endenden Nullzeichens, zurück.

unsigned int Length() const throw();

Rückgabewert

Die Länge des m_str Elements.

Beispiel

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

unsigned int len = bstrTemp.Length();

ATLASSERT(len == 11);

CComBSTR::LoadString

Lädt eine durch nID dieses Objekt angegebene Zeichenfolgenressource und speichert sie.

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

Parameter

Siehe LoadString im Windows SDK.

Rückgabewert

Gibt zurück TRUE , wenn die Zeichenfolge erfolgreich geladen wurde; andernfalls wird zurückgegeben FALSE.

Hinweise

Die erste Funktion lädt die Ressource aus dem modul, das sie über den hInst Parameter identifiziert hat. Die zweite Funktion lädt die Ressource aus dem Ressourcenmodul, das dem CComModulein diesem Projekt verwendeten abgeleiteten Objekt zugeordnet ist.

Beispiel

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

Enthält das BSTR zugeordnete CComBSTR Objekt.

BSTR m_str;

Beispiel

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

Wandelt ein CComBSTR Objekt in ein BSTR.

operator BSTR() const throw();

Hinweise

Ermöglicht das Übergeben CComBSTR von Objekten an Funktionen mit [in] BSTR -Parametern.

Beispiel

Ein Beispiel hierfür finden Sie unter CComBSTR::m_str.

CComBSTR::operator !

Überprüft, ob BSTR Zeichenfolge ist NULL.

bool operator!() const throw();

Rückgabewert

Gibt zurück TRUE , wenn das m_str Element ist NULL; andernfalls FALSE.

Hinweise

Dieser Operator sucht nur nach einem NULL Wert, nicht nach einer leeren Zeichenfolge.

Beispiel

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

Gibt das logische Gegenteil von operator ==.

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

Parameter

bstrSrc
[in] Ein CComBSTR-Objekt.

pszSrc
[in] Eine leere Zeichenfolge.

nNull
[in] Muss NULL sein.

Rückgabewert

Gibt zurück TRUE , wenn das zu vergleichende Element nicht dem Objekt entspricht CComBSTR ; andernfalls wird zurückgegeben FALSE.

Hinweise

CComBSTRs werden im Kontext des Standardgebietsschemas des Benutzers textual verglichen. Der letzte Vergleichsoperator vergleicht einfach die enthaltene Zeichenfolge mit NULL.

CComBSTR::operator &

Gibt die Adresse des BSTR gespeicherten Elements zurück m_str .

BSTR* operator&() throw();

Hinweise

CComBstr operator & hat eine spezielle Assertion, die damit verbunden ist, um Speicherlecks zu identifizieren. Das Programm wird bestätigt, wenn das m_str Mitglied initialisiert wird. Diese Assertion wurde erstellt, um Situationen zu identifizieren, in denen ein Programmierer den & operator neuen Wert einem Member zuweist m_str , ohne die erste Zuordnung von m_str. Wenn m_str gleich NULL, geht das Programm davon aus, dass m_str noch nicht zugeordnet wurde. In diesem Fall wird das Programm nicht geltend gemacht.

Diese Assertion ist standardmäßig nicht aktiviert. Definieren, ATL_CCOMBSTR_ADDRESS_OF_ASSERT um diese Assertion zu aktivieren.

Beispiel

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

Fügt eine Zeichenfolge an das CComBSTR Objekt an.

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

Parameter

bstrSrc
[in] Ein CComBSTR anzufügende Objekt.

pszSrc
[in] Eine anzufügende Null-Zeichenfolge.

Hinweise

CComBSTRs werden im Kontext des Standardgebietsschemas des Benutzers textual verglichen. Der LPCOLESTR Vergleich erfolgt mithilfe memcmp der Rohdaten in jeder Zeichenfolge. Der LPCSTR Vergleich erfolgt auf die gleiche Weise, nachdem eine temporäre Unicode-Kopie pszSrc erstellt wurde. Der letzte Vergleichsoperator vergleicht einfach die enthaltene Zeichenfolge mit NULL.

Beispiel

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 <

Vergleicht eine CComBSTR mit einer Zeichenfolge.

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

Rückgabewert

Gibt zurück TRUE , wenn das verglichene Element kleiner als das CComBSTR Objekt ist; andernfalls wird zurückgegeben FALSE.

Hinweise

Der Vergleich wird mithilfe des Standardgebietsschemas des Benutzers ausgeführt.

CComBSTR::operator =

Legt das m_str Element auf eine Kopie des pSrc Elements oder auf eine Kopie des BSTR Elements von src. Der Verschiebungszuweisungsoperator wird verschoben src , ohne ihn zu kopieren.

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

Hinweise

Der pSrc Parameter gibt entweder eine LPCOLESTR für Unicode-Versionen oder LPCSTR für ANSI-Versionen an.

Beispiel

Ein Beispiel hierfür finden Sie unter CComBSTR::Copy.

CComBSTR::operator ==

Vergleicht eine CComBSTR mit einer Zeichenfolge. CComBSTRs werden im Kontext des Standardgebietsschemas des Benutzers textual verglichen.

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

Parameter

bstrSrc
[in] Ein CComBSTR-Objekt.

pszSrc
[in] Eine leere Zeichenfolge.

nNull
[in] Muss sein NULL.

Rückgabewert

Gibt zurück TRUE , wenn das zu vergleichende Element dem Objekt entspricht CComBSTR ; andernfalls wird zurückgegeben FALSE.

Hinweise

Der letzte Vergleichsoperator vergleicht einfach die enthaltene Zeichenfolge mit NULL.

CComBSTR::operator >

Vergleicht eine CComBSTR mit einer Zeichenfolge.

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

Rückgabewert

Gibt zurück TRUE , wenn das verglichene Element größer als das CComBSTR Objekt ist; andernfalls wird zurückgegeben FALSE.

Hinweise

Der Vergleich wird mithilfe des Standardgebietsschemas des Benutzers ausgeführt.

CComBSTR::ReadFromStream

Legt das m_str Element auf das BSTR im angegebenen Datenstrom enthaltene Element fest.

HRESULT ReadFromStream(IStream* pStream) throw();

Parameter

pStream
[in] Ein Zeiger auf die IStream Schnittstelle im Datenstrom, der die Daten enthält.

Rückgabewert

Ein Standard HRESULT -Wert.

Hinweise

ReadToStream erfordert, dass der Inhalt des Datenstroms an der aktuellen Position mit dem datenformat kompatibel ist, das von einem Aufruf WriteToStreamausgeschrieben wurde.

Beispiel

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

Konvertiert die enthaltene Zeichenfolge in Kleinbuchstaben.

HRESULT ToLower() throw();

Rückgabewert

Ein Standard HRESULT -Wert.

Hinweise

Weitere Informationen zur Ausführung der Konvertierung finden Sie CharLowerBuff unter.

CComBSTR::ToUpper

Konvertiert die enthaltene Zeichenfolge in Großbuchstaben.

HRESULT ToUpper() throw();

Rückgabewert

Ein Standard HRESULT -Wert.

Hinweise

Weitere Informationen zur Ausführung der Konvertierung finden Sie CharUpperBuff unter.

CComBSTR::WriteToStream

Speichert das m_str Element in einem Datenstrom.

HRESULT WriteToStream(IStream* pStream) throw();

Parameter

pStream
[in] Ein Zeiger auf die IStream Schnittstelle in einem Datenstrom.

Rückgabewert

Ein Standard HRESULT -Wert.

Hinweise

Sie können einen BSTR aus dem Inhalt des Datenstroms mithilfe der ReadFromStream Funktion neu erstellen.

Beispiel

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

Siehe auch

Klassenübersicht
ATL- und MFC-Zeichenfolgenkonvertierungsmakros