CStringT-Klasse

Diese Klasse stellt ein CStringT -Objekt dar.

Syntax

template<typename BaseType, class StringTraits>
class CStringT :
    public CSimpleStringT<BaseType,
        _CSTRING_IMPL_::_MFCDLLTraitsCheck<BaseType, StringTraits>::c_bIsMFCDLLTraits>

Parameter

BaseType
Der Zeichentyp der Zeichenfolgenklasse. Dabei kann es sich um eine der folgenden Methoden handeln:

  • char (für ANSI-Zeichenfolgen).

  • wchar_t (für Unicode-Zeichenfolgen).

  • TCHAR (für ANSI- und Unicode-Zeichenfolgen).

StringTraits
Bestimmt, ob die Zeichenfolgenklasse unterstützung für die C Run-Time (CRT)-Bibliothek benötigt und wo sich Zeichenfolgenressourcen befinden. Dabei kann es sich um eine der folgenden Methoden handeln:

  • StrTraitATL<wchar_t | char | TCHAR, ChTraitsCRT<wchar_t | char | TCHAR>>

    Die -Klasse erfordert CRT-Unterstützung und sucht in dem von angegebenen Modul m_hInstResource (einem Member der Modulklasse der Anwendung) nach Ressourcenzeichenfolgen.

  • StrTraitATL<wchar_t | char | TCHAR, ChTraitsOS<wchar_t | char |TCHAR>>

    Die -Klasse erfordert keine CRT-Unterstützung und sucht nach Ressourcenzeichenfolgen in dem von angegebenen Modul m_hInstResource (ein Member der Modulklasse der Anwendung).

  • StrTraitMFC<wchar_t | char | TCHAR, ChTraitsCRT<wchar_t | char | TCHAR>>

    Die -Klasse erfordert CRT-Unterstützung und sucht mithilfe des MFC-Standardsuchalgorithmus nach Ressourcenzeichenfolgen.

  • StrTraitMFC<wchar_t | char | TCHAR, ChTraitsOS<wchar_t | char | TCHAR>>

    Die -Klasse erfordert keine CRT-Unterstützung und sucht mithilfe des MFC-Standardsuchalgorithmus nach Ressourcenzeichenfolgen.

Member

Öffentliche Konstruktoren

name BESCHREIBUNG
CStringT::CStringT Erstellt ein CStringT -Objekt auf verschiedene Weise.
CStringT::~CStringT Zerstört ein CStringT -Objekt.

Öffentliche Methoden

name BESCHREIBUNG
CStringT::AllocSysString Ordnet eine BSTR aus CStringT Daten zu.
CStringT::AnsiToOem Konvertiert den ANSI-Zeichensatz in den OEM-Zeichensatz.
CStringT::AppendFormat Fügt formatierte Daten an ein vorhandenes CStringT Objekt an.
CStringT::Collate Vergleicht zwei Zeichenfolgen (wobei die Groß-/Kleinschreibung beachtet wird, wobei gebietsschemaspezifische Informationen verwendet werden).
CStringT::CollateNoCase Vergleicht zwei Zeichenfolgen (ohne Berücksichtigung der Groß-/Kleinschreibung, verwendet gebietsschemaspezifische Informationen).
CStringT::Compare Vergleicht zwei Zeichenfolgen (Groß-/Kleinschreibung wird beachtet).
CStringT::CompareNoCase Vergleicht zwei Zeichenfolgen (ohne Unterscheidung nach Groß-/Kleinschreibung).
CStringT::Delete Löscht ein Oder mehrere Zeichen aus einer Zeichenfolge.
CStringT::Find Sucht ein Zeichen oder eine Teilzeichenfolge innerhalb einer größeren Zeichenfolge.
CStringT::FindOneOf Sucht das erste übereinstimmende Zeichen aus einem Satz.
CStringT::Format Formatiert die Zeichenfolge wie sprintf bezieht.
CStringT::FormatMessage Formatiert eine Meldungszeichenfolge.
CStringT::FormatMessageV Formatiert eine Nachrichtenzeichenfolge mithilfe einer Variablenargumentliste.
CStringT::FormatV Formatiert die Zeichenfolge mithilfe einer Variablenliste von Argumenten.
CStringT::GetEnvironmentVariable Legt die Zeichenfolge auf den Wert der angegebenen Umgebungsvariablen fest.
CStringT::Insert Fügt ein einzelnes Zeichen oder eine Teilzeichenfolge am angegebenen Index innerhalb der Zeichenfolge ein.
CStringT::Left Extrahiert den linken Teil einer Zeichenfolge.
CStringT::LoadString Lädt ein vorhandenes CStringT Objekt aus einer Windows Ressource.
CStringT::MakeLower Konvertiert alle Zeichen in dieser Zeichenfolge in Kleinbuchstaben.
CStringT::MakeReverse Kehrt die Zeichenfolge um.
CStringT::MakeUpper Konvertiert alle Zeichen in dieser Zeichenfolge in Großbuchstaben.
CStringT::Mid Extrahiert den mittleren Teil einer Zeichenfolge.
CStringT::OemToAnsi Konvertiert den OEM-Zeichensatz in den ANSI-Zeichensatz.
CStringT::Remove Entfernt angegebene Zeichen aus einer Zeichenfolge.
CStringT::Replace Ersetzt die angegebenen Zeichen durch andere Zeichen.
CStringT::ReverseFind Sucht ein Zeichen in einer größeren Zeichenfolge. beginnt am Ende.
CStringT::Right Extrahiert den rechten Teil einer Zeichenfolge.
CStringT::SetSysString Legt ein vorhandenes BSTR -Objekt mit Daten aus einem CStringT -Objekt fest.
CStringT::SpanExcluding Extrahiert Zeichen aus der Zeichenfolge, beginnend mit dem ersten Zeichen, die sich nicht in dem durch identifizierten Zeichensatz pszCharSet befinden.
CStringT::SpanIncluding Extrahiert eine Teilzeichenfolge, die nur die Zeichen in einem Satz enthält.
CStringT::Tokenize Extrahiert angegebene Token in einer Zielzeichenfolge.
CStringT::Trim Entfernt alle führenden und nachgestellten Leerzeichen aus der Zeichenfolge.
CStringT::TrimLeft Entfernt führende Leerzeichen aus der Zeichenfolge.
CStringT::TrimRight Entfernt nachfolgende Leerzeichen aus der Zeichenfolge.

Operatoren

Name BESCHREIBUNG
CStringT::operator = Weist einem -Objekt einen neuen Wert CStringT zu.
CStringT::operator + Verkettet zwei Zeichenfolgen oder ein Zeichen und eine Zeichenfolge.
CStringT::operator += Verkettet eine neue Zeichenfolge am Ende einer vorhandenen Zeichenfolge.
CStringT::operator == Bestimmt, ob zwei Zeichenfolgen logisch gleich sind.
CStringT::operator != Bestimmt, ob zwei Zeichenfolgen nicht logisch gleich sind.
CStringT::operator < Bestimmt, ob die Zeichenfolge links vom Operator kleiner als die Zeichenfolge auf der rechten Seite ist.
CStringT::operator > Bestimmt, ob die Zeichenfolge links vom Operator größer als die Zeichenfolge rechts vom Operator ist.
CStringT::operator <= Bestimmt, ob die Zeichenfolge links vom Operator kleiner oder gleich der Zeichenfolge rechts vom Operator ist.
CStringT::operator >= Bestimmt, ob die Zeichenfolge links vom Operator größer oder gleich der Zeichenfolge rechts vom Operator ist.

Bemerkungen

CStringTerbt von CStringT. Erweiterte Features, z. B. Zeichenbearbeitung, Sortierung und Suche, werden von CStringT implementiert.

Hinweis

CStringT -Objekte können Ausnahmen auslösen. Dies tritt auf, wenn für ein CStringT -Objekt aus irgendeinem Grund nicht genügend Arbeitsspeicher verfügbar ist.

Ein CStringT -Objekt besteht aus einer Zeichensequenz variabler Länge. CStringT stellt Funktionen und Operatoren mit einer Syntax bereit, die der von Basic ähnelt. Verkettungs- und Vergleichsoperatoren sowie eine vereinfachte Speicherverwaltung erleichtern CStringT die Verwendung von Objekten als normale Zeichenarrays.

Hinweis

Obwohl es möglich CStringT ist, Instanzen zu erstellen, die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und Operatoren für CStringT Objekte, die eingebettete NULL-Zeichen enthalten, kann zu unbeabsichtigten Ergebnissen führen.

Durch die Verwendung verschiedener Kombinationen der BaseType Parameter und können Objekte in den folgenden Typen enthalten StringTraitsCStringT sein, die von den ATL-Bibliotheken vordefiniert wurden.

Bei Verwendung in einer ATL-Anwendung:

CStringCStringA, und werden aus der CStringW MFC-DLL (MFC90.DLL) exportiert, nie aus Benutzer-DLLs. Dadurch wird verhindert, dass CStringT mehrmals definiert wird.

Hinweis

Wenn Ihr Code die Problemumgehung für Linkerfehler enthält, die unter Exportieren von Zeichenfolgenklassen mit CStringTbeschrieben werden, sollten Sie diesen Code entfernen. Es wird nicht mehr benötigt.

Die folgenden Zeichenfolgentypen sind in MFC-basierten Anwendungen verfügbar:

CStringT-Typ Deklaration
CStringA Eine ZEICHENFOLGE vom Typ ANSI mit CRT-Unterstützung.
CStringW Eine Unicode-Zeichenfolge mit CRT-Unterstützung.
CString Sowohl ANSI- als auch Unicode-Zeichentypen mit CRT-Unterstützung.

Die folgenden Zeichenfolgentypen sind in Projekten verfügbar, in denen ATL_CSTRING_NO_CRT definiert ist:

CStringT-Typ Deklaration
CAtlStringA Eine ANSI-Zeichenfolge ohne CRT-Unterstützung.
CAtlStringW Eine Unicode-Zeichenfolge ohne CRT-Unterstützung.
CAtlString Sowohl ANSI- als auch Unicode-Zeichentypen ohne CRT-Unterstützung.

Die folgenden Zeichenfolgentypen sind in Projekten verfügbar, ATL_CSTRING_NO_CRT in denen nicht definiert ist:

CStringT-Typ Deklaration
CAtlStringA Eine ANSI-Zeichenfolge mit CRT-Unterstützung.
CAtlStringW Eine Unicode-Zeichenfolge mit CRT-Unterstützung.
CAtlString Sowohl ANSI- als auch Unicode-Zeichentypen mit CRT-Unterstützung.

CString -Objekte haben außerdem die folgenden Merkmale:

  • CStringT -Objekte können aufgrund von Verkettungsvorgängen wachsen.

  • CStringT -Objekte folgen der "Wertsemantik". Stellen Sie sich CStringT ein -Objekt als tatsächliche Zeichenfolge vor, nicht als Zeiger auf eine Zeichenfolge.

  • Sie können CStringT Funktionsargumente frei durch PCXSTR Objekte ersetzen.

  • Benutzerdefinierte Speicherverwaltung für Zeichenfolgenpuffer. Weitere Informationen finden Sie unter Speicherverwaltung und .

Vordefinierte CStringT-Typen

Da ein Vorlagenargument verwendet, um den unterstützten Zeichentyp (entweder oder ) zu definieren, können CStringTwchar_tchar Methodenparametertypen manchmal kompliziert sein. Um dieses Problem zu vereinfachen, wird ein Satz vordefinierter Typen definiert und in der gesamten Klasse CStringT verwendet. In der folgenden Tabelle sind die verschiedenen Typen aufgeführt:

Name BESCHREIBUNG
XCHAR Ein einzelnes Zeichen (entweder wchar_tchar oder ) mit demselben Zeichentyp wie das CStringT -Objekt.
YCHAR Ein einzelnes Zeichen (entweder wchar_t oder ) mit dem char entgegengesetzten Zeichentyp als CStringT Objekt.
PXSTR Ein Zeiger auf eine Zeichenfolge (entweder wchar_t oder char ) mit demselben Zeichentyp wie das CStringT -Objekt.
PYSTR Ein Zeiger auf eine Zeichenfolge (entweder wchar_t oder ) mit dem char entgegengesetzten Zeichentyp als CStringT Objekt.
PCXSTR Ein Zeiger auf eine const Zeichenfolge (entweder wchar_t oder ) mit char demselben Zeichentyp wie das CStringT -Objekt.
PCYSTR Ein Zeiger auf eine const Zeichenfolge (entweder wchar_t oder ) mit dem char entgegengesetzten Zeichentyp als CStringT Objekt.

Hinweis

Code, der zuvor nicht dokumentierte Methoden von (z. B. ) verwendet hat, muss durch Code ersetzt werden, der die folgenden dokumentierten Methoden von CStringAssignCopy verwendet (z. CStringT B. oder GetBufferReleaseBuffer ). Diese Methoden werden von CSimpleStringT geerbt.

Vererbungshierarchie

CSimpleStringT

CStringT

Requirements (Anforderungen)

Header Zweck
cstringt.h Nur MFC-Zeichenfolgenobjekte
atlstr.h Nicht-MFC-Zeichenfolgenobjekte

CStringT::AllocSysString

Ordnet eine Automation-kompatible Zeichenfolge des Typs zu und kopiert den Inhalt des Objekts, einschließlich des beendenden BSTRCStringT NULL-Zeichens.

BSTR AllocSysString() const;

Rückgabewert

Die neu zugeordnete Zeichenfolge.

Bemerkungen

In MFC-Programmen wird eine Klasse ausgelöst, wenn nicht genügend Arbeitsspeicher vorhanden ist. In ATL-Programmen wird CAtlException eine ausgelöst. Diese Funktion wird normalerweise zum Zurückgeben von Zeichenfolgen für Automation verwendet.

Wenn diese Zeichenfolge häufig als Parameter an eine COM-Funktion übergeben wird, muss der [in] Aufrufer die Zeichenfolge freigibt. Dies kann mithilfe von SysFreeString erfolgen, wie im Windows SDK beschrieben. Weitere Informationen finden Sie unter Allocating and Releasing Memory for a .

Weitere Informationen zu OLE-Zuordnungsfunktionen in Windows finden Sie SysAllocString im Windows SDK.

Beispiel

Das folgende Beispiel veranschaulicht die Verwendung von CStringT::AllocSysString.

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString str(_T("This is a test string!"));
BSTR bstr = str.AllocSysString();

// bstr now contains "This is a test string!", and can be
// passed to any OLE function requiring a BSTR.
// Normally, if you pass the BSTR, you will
// need to free the string after returning from the function call.   

CStringT::AnsiToOem

Konvertiert alle Zeichen in diesem Objekt aus CStringT dem ANSI-Zeichensatz in den OEM-Zeichensatz.

void AnsiToOem();

Bemerkungen

Die Funktion ist nicht verfügbar, wenn _UNICODE definiert ist.

Beispiel

// OEM character 252 on most IBM-compatible computers in
// Western countries/regions is superscript n, as in 2^n.
// Converting it to the ANSI English charset results in a
// normal character 'n', which is the closest possible
// representation.

CStringT<char, StrTraitATL<char, ChTraitsCRT<char>>> str((WCHAR)252);
str.OemToAnsi();
ASSERT(str[0] == 'n');

// Be aware that in OEM to ANSI conversion the 'n'
// from the previous result cannot be converted back to
// a supsercript n because the system does not know what
// the character's value truly was.
str.AnsiToOem();
ASSERT(str[0] != 252);
ASSERT(str[0] == 'n');   

CStringT::AppendFormat

Fügt formatierte Daten an ein vorhandenes Objekt CStringT an.

void __cdecl AppendFormat(PCXSTR pszFormat, [, argument] ...);
void __cdecl AppendFormat(UINT nFormatID, [, argument] ...);

Parameter

pszFormat
Eine Formatsteuerzeichenfolge.

nFormatID
Der Zeichenfolgenressourcenbezeichner, der die Formatsteuerzeichenfolge enthält.

argument
Optionale Argumente.

Bemerkungen

Diese Funktion formatiert und fügt eine Reihe von Zeichen und Werten im CStringT an. Jedes optionale Argument (sofern verfügbar) wird entsprechend der entsprechenden Formatspezifikation in oder aus der durch identifizierten pszFormat Zeichenfolgenressource konvertiert und nFormatID angefügt.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str = _T("Some data:\t");

str.AppendFormat(_T("X value = %.2f\n"), 12345.12345);
_tprintf_s(_T("%s"), (LPCTSTR) str);

CStringT::Collate

Vergleicht zwei Zeichenfolgen mithilfe der generischen Textfunktion _tcscoll .

int Collate(PCXSTR psz) const throw();

Parameter

psz
Die andere Zeichenfolge, die für den Vergleich verwendet wird.

Rückgabewert

Null, wenn die Zeichenfolgen identisch sind, 0, wenn dieses Objekt kleiner als ist, oder <CStringTpsz 0, wenn dieses > Objekt größer als CStringTpsz ist.

Bemerkungen

Die generische Textfunktion , die in definiert ist, wird abhängig vom Zeichensatz, der zur Kompilierzeit definiert ist, entweder , oder _tcscollTCHAR.H zu strcollwcscoll_mbscoll . Jede Funktion vergleicht die Zeichenfolgen gemäß der aktuell verwendeten Codepage mit Schreibung. Weitere Informationen finden Sie unter , , , , wcscoll_mbscoll , _strcoll_l_wcscoll_l _mbscoll_l.

CStringT::CollateNoCase

Vergleicht zwei Zeichenfolgen mithilfe der generischen Textfunktion _tcscoll .

int CollateNoCase(PCXSTR psz) const throw();

Parameter

psz
Die andere Zeichenfolge, die für den Vergleich verwendet wird.

Rückgabewert

0 (null), wenn die Zeichenfolgen identisch sind (groß-/unter-ignorierend), 0 , wenn dieses Objekt kleiner als ist (groß-/unter-/aus-ignorierend). <CStringTpsz>CStringTpsz

Bemerkungen

Die generische Textfunktion , die in definiert ist, wird abhängig vom Zeichensatz, der zur Kompilierzeit definiert ist, entweder , oder _tcscollTCHAR.H zu stricollwcsicoll_mbsicoll . Jede Funktion führt einen Vergleich der Zeichenfolgen durch, bei dem die Groß-/Kleinschreibung nicht beachtet wird, entsprechend der aktuell verwendeten Codepage. Weitere Informationen finden Sie unter , , , wcscoll , _mbscoll_strcoll_l_wcscoll_l , _mbscoll_l.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str1 = _T("Co-Op");
CAtlString str2 = _T("con");

int n;

// Collation uses language rules, such as ignoring dashes.
// NoCase version ignores case.
n = str1.CollateNoCase(str2);
ASSERT(n < 0);

// Comparison is a strict ASCII comparison with no language rules
// but still ignores case in NoCase version.
n = str1.CompareNoCase(str2);
ASSERT(n < 0);   

CStringT::Compare

Vergleicht zwei Zeichenfolgen (bei der die Schreibung beachtet wird).

int Compare(PCXSTR psz) const;

Parameter

psz
Die andere Zeichenfolge, die für den Vergleich verwendet wird.

Rückgabewert

Null, wenn die Zeichenfolgen identisch sind, 0, wenn dieses Objekt kleiner als ist, oder <CStringTpsz 0, wenn dieses > Objekt größer als CStringTpsz ist.

Bemerkungen

Die generische Textfunktion , die in definiert ist, wird abhängig vom Zeichensatz, der zur Kompilierzeit definiert ist, entweder , oder _tcscmpTCHAR.H zu strcmpwcscmp_mbscmp . Jede Funktion führt einen Vergleich der Zeichenfolgen durch, bei dem die Schreibung beachtet wird, und ist nicht vom -Locale betroffen. Weitere Informationen finden Sie unter , wcscmp , _mbscmp.

Wenn die Zeichenfolge eingebettete NULL-Werte enthält, wird die Zeichenfolge zum Vergleich beim ersten eingebetteten NULL-Zeichen als abgeschnitten betrachtet.

Beispiel

Das folgende Beispiel veranschaulicht die Verwendung von CStringT::Compare.

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s1(_T("abc"));
CAtlString s2(_T("abd"));
ASSERT(s1.Compare(s2) < 0);    // Compare with another CAtlString.
ASSERT(s1.Compare(_T("abe")) < 0); // Compare with LPTSTR string.   

CStringT::CompareNoCase

Vergleicht zwei Zeichenfolgen (ohne Unterschiedliche Groß-/Kleinschreibung).

int CompareNoCase(PCXSTR psz) const throw();

Parameter

psz
Die andere Zeichenfolge, die für den Vergleich verwendet wird.

Rückgabewert

0 (null), wenn die Zeichenfolgen identisch sind (groß-/unter-ignorierend), 0 , wenn dieses Objekt kleiner als ist (groß-/unter-/aus-ignorierend). <CStringTpsz>CStringTpsz

Bemerkungen

Die generische Textfunktion , die in definiert ist, wird abhängig vom zeichenbasierten Satz, der zur Kompilierzeit definiert ist, entweder oder _tcsicmpTCHAR.H zu - oder _stricmp_wcsicmp_mbsicmp -Zeichensatz. Jede Funktion führt einen Vergleich der Zeichenfolgen durch, bei dem die Groß-/Kleinschreibung nicht beachtet wird. Der Vergleich hängt vom Aspekt LC_CTYPE des -Locale ab, aber nicht LC_COLLATE vom -Aspekt. Weitere Informationen finden Sie unter , , , _wcsicmp , _mbsicmp_stricmp_l_wcsicmp_l , _mbsicmp_l.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s1(_T("abc"));
CAtlString s2(_T("ABD"));
ASSERT(s1.CompareNoCase(s2) < 0); // Compare with a CAtlString.
ASSERT(s1.CompareNoCase(_T("ABE")) < 0); // Compare with LPTSTR string.   

CStringT::CStringT

Erstellt ein CStringT-Objekt.

CStringT() throw() :
    CThisSimpleString(StringTraits::GetDefaultManager());

explicit CStringT(IAtlStringMgr* pStringMgr) throw() :
    CThisSimpleString( pStringMgr);

CStringT(const VARIANT& varSrc);

CStringT(const VARIANT& varSrc, IAtlStringMgr* pStringMgr);

CStringT(const CStringT& strSrc) :
    CThisSimpleString( strSrc);

operator CSimpleStringT<
                    BaseType,
                    !_CSTRING_IMPL_::_MFCDLLTraitsCheck<BaseType, StringTraits>
                    :: c_bIsMFCDLLTraits> &()

template <bool bMFCDLL>
CStringT(const CSimpleStringT<BaseType, bMFCDLL>& strSrc) :
    CThisSimpleString( strSrc);

template <class SystemString>
CStringT(SystemString^ pString) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(const XCHAR* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CSTRING_EXPLICIT CStringT(const YCHAR* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(LPCSTR pszSrc, IAtlStringMgr* pStringMgr) :
    CThisSimpleString( pStringMgr);

CStringT(LPCWSTR pszSrc, IAtlStringMgr* pStringMgr) :
    CThisSimpleString( pStringMgr);

CSTRING_EXPLICIT CStringT(const unsigned char* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

/*CSTRING_EXPLICIT*/ CStringT(char* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CSTRING_EXPLICIT CStringT(unsigned char* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CSTRING_EXPLICIT CStringT(wchar_t* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(const unsigned char* pszSrc, IAtlStringMgr* pStringMgr) :
    CThisSimpleString( pStringMgr);

CSTRING_EXPLICIT CStringT(char ch, int nLength = 1) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CSTRING_EXPLICIT CStringT(wchar_t ch, int nLength = 1) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(const XCHAR* pch, int nLength) :
    CThisSimpleString( pch, nLength, StringTraits::GetDefaultManager());

CStringT(const YCHAR* pch, int nLength) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(const XCHAR* pch, int nLength, AtlStringMgr* pStringMgr) :
    CThisSimpleString( pch, nLength, pStringMgr);

CStringT(const YCHAR* pch, int nLength, IAtlStringMgr* pStringMgr) :
    CThisSimpleString( pStringMgr);

Parameter

pch
Ein Zeiger auf ein Array von Zeichen der Länge nLength , nicht auf NULL terminiert.

nLength
Die Anzahl der Zeichen in pch .

ch
Ein einzelnes Zeichen.

pszSrc
Eine auf NULL beendete Zeichenfolge, die in dieses Objekt kopiert werden CStringT soll.

pStringMgr
Ein Zeiger auf den Speicher-Manager für das CStringT -Objekt. Weitere Informationen zur - IAtlStringMgr und -Speicherverwaltung für CStringT finden Sie unter IAtlStringMgr.

strSrc
Ein CStringT vorhandenes Objekt, das in dieses Objekt kopiert werden CStringT soll. Weitere Informationen zu CThisString und finden Sie im Abschnitt CThisSimpleString "Hinweise".

varSrc
Ein Variant-Objekt, das in dieses Objekt kopiert werden CStringT soll.

BaseType
Der Zeichentyp der Zeichenfolgenklasse. Dabei kann es sich um eine der folgenden Methoden handeln:

char (für ANSI-Zeichenfolgen).

wchar_t (für Unicode-Zeichenfolgen).

TCHAR (für ANSI- und Unicode-Zeichenfolgen).

bMFCDLL
Boolescher Wert, der angibt, ob das Projekt eine MFC-DLL ( TRUE ) ist oder nicht ( FALSE ).

SystemString
Muss System::String sein, und das Projekt muss mit kompiliert /clr werden.

pString
Ein Handle für ein CStringT -Objekt.

Bemerkungen

Da die Konstruktoren die Eingabedaten in einen neuen zugeordneten Speicher kopieren, können Speicherausnahmen entstehen. Einige dieser Konstruktoren fungieren als Konvertierungsfunktionen. Dadurch können Sie z. B. ein ersetzen, LPTSTR bei dem ein CStringT -Objekt erwartet wird.

  • CStringT( LPCSTRlpsz ): Erstellt einen Unicode aus CStringT einer ANSI-Zeichenfolge. Sie können diesen Konstruktor auch verwenden, um eine Zeichenfolgenressource zu laden, wie im folgenden Beispiel gezeigt.

  • CStringT(LPCWSTRlpsz ): Erstellt eine aus CStringT einer Unicode-Zeichenfolge.

  • CStringT( const unsigned char*psz ): Ermöglicht das Erstellen eines aus einem CStringT Zeiger auf unsigned char .

Hinweis

Definieren Sie das _CSTRING_DISABLE_NARROW_WIDE_CONVERSION Makro, um die implizite Zeichenfolgenkonvertierung zwischen ANSI- und Unicode-Zeichenfolgen zu deaktivieren. Das -Makro schließt kompilierungskonstruktoren aus, die die Konvertierung unterstützen.

Der strSrc -Parameter kann entweder ein - oder CStringT ein CThisSimpleString -Objekt sein. Verwenden CStringT Sie für eine der Standard instanziierungen ( , oder ); für , verwenden Sie CString einen CStringACStringWCThisSimpleStringthis -Zeiger. CThisSimpleStringdeklariert eine Instanz der CThisSimpleStringbei der es sich um eine kleinere Zeichenfolgenklasse mit weniger integrierten Funktionen als die -Klasse CStringT handelt.

Der CSimpleStringT<>&() Überladungsoperator erstellt ein CStringT -Objekt aus einer CSimpleStringT Deklaration.

Hinweis

Obwohl es möglich ist, Instanzen zu erstellen, CStringT die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und CStringT Operatoren für Objekte, die eingebettete NULL-Zeichen enthalten, kann zu unbeabsichtigten Ergebnissen führen.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s1;                    // Empty string
CAtlString s2(_T("cat"));           // From a C string literal
CAtlString s3 = s2;               // Copy constructor
CAtlString s4(s2 + _T(" ") + s3);   // From a string expression

CAtlString s5(_T('x'));             // s5 = "x"
CAtlString s6(_T('x'), 6);          // s6 = "xxxxxx"

CAtlString s7((LPCSTR)ID_FILE_NEW); // s7 = "Create a new document"

VARIANT var;
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = ::SysAllocString(L"Football is a fun sport.");
CAtlString s8(var); // s8 = "Football is a fun sport."

// The following statement does not call the assignment operator.
// The compiler considers the following statement equivalent to
// CAtlString city("Paris")
CAtlString city = _T("Paris");   

CStringT::~CStringT

Zerstört das CStringT-Objekt.

~CStringT() throw();

Bemerkungen

Zerstört das CStringT-Objekt.

CStringT::Delete

Löscht ein oder mehrere Zeichen aus einer Zeichenfolge, beginnend mit dem Zeichen am angegebenen Index.

int Delete(int iIndex, int nCount = 1);

Parameter

iIndex
Der nullbasierte Index des ersten Zeichens im CStringT zu löschenden Objekt.

nCount
Die Anzahl der zu entfernenden Zeichen.

Rückgabewert

Die Länge der geänderten Zeichenfolge.

Bemerkungen

Wenn nCount länger als die Zeichenfolge ist, wird der Rest der Zeichenfolge entfernt.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str(_T("Soccer is best, but hockey is quicker!"));
_tprintf_s(_T("Before: %s\n"), (LPCTSTR)str);

int n = str.Delete(6, 3);
_tprintf_s(_T("After: %s\n"), (LPCTSTR)str);
ASSERT(n == str.GetLength());
Before: Soccer is best,
    but hockey is quicker!
After: Soccer best,
    but hockey is quicker!

CStringT::Find

Durchsucht diese Zeichenfolge nach der ersten Übereinstimmung eines Zeichens oder einer Teilzeichenfolge.

int Find(PCXSTR pszSub, int iStart=0) const throw();
int Find(XCHAR ch, int iStart=0) const throw();

Parameter

pszSub
Eine zu suchende Teilzeichenfolge.

iStart
Der Index des Zeichens in der Zeichenfolge, mit dem die Suche beginnen soll, oder 0, um von Anfang an zu beginnen.

ch
Ein einzelnes Zeichen, nach dem gesucht werden soll.

Rückgabewert

Der nullbasierte Index des ersten Zeichens in diesem Objekt, das der angeforderten Teilzeichenfolge oder den angeforderten Zeichen entspricht; -1, wenn die Teilzeichenfolge oder das Zeichen CStringT nicht gefunden wird.

Bemerkungen

Die -Funktion wird überladen, um sowohl einzelne Zeichen (ähnlich der Laufzeitfunktion ) als auch Zeichenfolgen strchr (ähnlich wie ) zu strstr akzeptieren.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abcdef"));
ASSERT(s.Find(_T('c')) == 2);
ASSERT(s.Find(_T("de")) == 3);

CAtlString str(_T("The waves are still"));
int n = str.Find(_T('e'), 5);
ASSERT(n == 7);   

CStringT::FindOneOf

Durchsucht diese Zeichenfolge nach dem ersten Zeichen, das einem beliebigen in enthaltenen Zeichen pszCharSet entspricht.

int FindOneOf(PCXSTR pszCharSet) const throw();

Parameter

pszCharSet
Eine Zeichenfolge, die Zeichen für den Abgleich enthält.

Rückgabewert

Der nullbasierte Index des ersten Zeichens in dieser Zeichenfolge, das sich ebenfalls in pszCharSet befindet; -1, wenn keine Übereinstimmung vorgibt.

Bemerkungen

Sucht das erste Vorkommen eines der Zeichen in pszCharSet .

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abcdef"));
ASSERT(s.FindOneOf(_T("xd")) == 3); // 'd' is first match   

CStringT::Format

Schreibt formatierte Daten auf die gleiche Weise in ein , CStringT das Daten in ein sprintf_s Zeichenarray im C-Stil formatiert.

void __cdecl Format(UINT nFormatID, [, argument]...);
void __cdecl Format(PCXSTR pszFormat,  [, argument] ...);

Parameter

nFormatID
Der Zeichenfolgenressourcenbezeichner, der die Formatsteuerzeichenfolge enthält.

pszFormat
Eine Formatsteuerzeichenfolge.

argument
Optionale Argumente.

Bemerkungen

Diese Funktion formatiert und speichert eine Reihe von Zeichen und Werten im CStringT . Jedes optionale Argument (sofern verfügbar) wird gemäß der entsprechenden Formatspezifikation in oder aus der durch identifizierten pszFormat Zeichenfolgenressource konvertiert und nFormatID ausgegeben.

Der Aufruf ist nicht möglich, wenn das Zeichenfolgenobjekt selbst als Parameter für angeboten Format wird. Der folgende Code führt beispielsweise zu unvorhersehbaren Ergebnissen:

CAtlString str = _T("Some Data");
str.Format(_T("%s%d"), str, 123);   
// Attention: str is also used in the parameter list.   

Weitere Informationen finden Sie unter FormatSpezifikationssyntax: und wprintf Funktionen.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString str;

str.Format(_T("Floating point: %.2f\n"), 12345.12345);
_tprintf_s(_T("%s"), (LPCTSTR) str);

str.Format(_T("Left-justified integer: %.6d\n"), 35);
_tprintf_s(_T("%s"), (LPCTSTR) str);

CStringT::FormatMessage

Formatiert eine Meldungszeichenfolge.

void __cdecl FormatMessage(UINT nFormatID, [, argument]...);
void __cdecl FormatMessage(PCXSTR pszFormat, [, argument]...);

Parameter

nFormatID
Der Zeichenfolgenressourcenbezeichner, der den unformatierten Meldungstext enthält.

pszFormat
Zeigt auf die Formatsteuerzeichenfolge. Es wird auf Einfügungen überprüft und entsprechend formatiert. Die Formatzeichenfolge ähnelt Formatzeichenfolgen im Laufzeitfunktionsformat, mit der Ausnahme, dass die Parameter in beliebiger printf Reihenfolge eingefügt werden können.

argument
Optionale Argumente.

Bemerkungen

Die Funktion erfordert eine Nachrichtendefinition als Eingabe. Die Nachrichtendefinition wird durch oder pszFormat von der Zeichenfolgenressource bestimmt, die durch identifiziert nFormatID wird. Die Funktion kopiert den formatierten Meldungstext in das -Objekt und verarbeitet bei Anfrage CStringT eingebettete Einfügesequenzen.

Hinweis

FormatMessage versucht, Systemspeicher für die neu formatierte Zeichenfolge zu reservieren. Wenn dieser Versuch fehlschlägt, wird automatisch eine Speicherausnahme ausgelöst.

Jede Einfügung muss einen entsprechenden Parameter nach dem -Parameter oder pszFormat dem nFormatID -Parameter haben. Innerhalb des Meldungstexts werden mehrere Escapesequenzen für die dynamische Formatierung der Nachricht unterstützt. Weitere Informationen finden Sie unter FormatMessage Windows-Funktion im Windows SDK.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str;
int nAsked = 5;
int nAgree = 4;

str.FormatMessage(_T("%1!d! of %2!d! writers agree: Soccer is %3%!"), 
   nAgree, nAsked, _T("Best"));
ASSERT(str == _T("4 of 5 writers agree: Soccer is Best!"));   

CStringT::FormatMessageV

Formatiert eine Meldungszeichenfolge mithilfe einer Variablenargumentliste.

void FormatMessageV(PCXSTR pszFormat, va_list* pArgList);

Parameter

pszFormat
Zeigt auf die Formatsteuerzeichenfolge. Es wird auf Einfügungen überprüft und entsprechend formatiert. Die Formatzeichenfolge ähnelt Formatzeichenfolgen im Laufzeitfunktionsformat, mit der Ausnahme, dass die Parameter in beliebiger printf Reihenfolge eingefügt werden können.

pArgList
Zeiger auf eine Liste von Argumenten.

Bemerkungen

Die Funktion erfordert eine Nachrichtendefinition als Eingabe, die durch bestimmt pszFormat wird. Die Funktion kopiert den formatierten Meldungstext und eine variable Liste von Argumenten in das -Objekt und verarbeitet bei Anfrage CStringT eingebettete Einfügesequenzen.

Hinweis

FormatMessageV ruft CStringT::FormatMessage auf, wodurch versucht wird, Systemspeicher für die neu formatierte Zeichenfolge zu reservieren. Wenn dieser Versuch fehlschlägt, wird automatisch eine Speicherausnahme ausgelöst.

Weitere Informationen finden Sie unter FormatMessage Windows-Funktion im Windows SDK.

CStringT::FormatV

Formatiert eine Meldungszeichenfolge mithilfe einer Variablenargumentliste.

void FormatV(PCXSTR pszFormat, va_list args);

Parameter

pszFormat
Zeigt auf die Formatsteuerzeichenfolge. Es wird auf Einfügungen überprüft und entsprechend formatiert. Die Formatzeichenfolge ähnelt Formatzeichenfolgen im Laufzeitfunktionsformat, mit der Ausnahme, dass die Parameter in beliebiger printf Reihenfolge eingefügt werden können.

args
Zeiger auf eine Liste von Argumenten.

Bemerkungen

Schreibt eine formatierte Zeichenfolge und eine Variablenliste von Argumenten auf die gleiche Weise in eine Zeichenfolge, die Daten in ein CStringTvsprintf_s Zeichenarray im C-Stil formatiert.

Beispiel

void WriteString(LPCTSTR pstrFormat, ...)
{
    CString str;

    // format and write the data you were given
    va_list args;
    va_start(args, pstrFormat);

    str.FormatV(pstrFormat, args);
    va_end(args);

    _tprintf_s(str);
    return;
}
// Call the above WriteString function.
WriteString(_T("%d error(s) found in %d line(s)"), 10, 1351);

CStringT::GetEnvironmentVariable

Legt die Zeichenfolge auf den Wert der angegebenen Umgebungsvariablen fest.

BOOL GetEnvironmentVariable(PCXSTR pszVar);

Parameter

pszVar
Zeiger auf eine auf NULL beendete Zeichenfolge, die die Umgebungsvariable angibt.

Rückgabewert

Ungleich Null, wenn erfolgreich, andernfalls 0 (Null).

Bemerkungen

Ruft den Wert der angegebenen Variablen aus dem Umgebungsblock des aufrufenden Prozesses ab. Der Wert hat die Form einer auf NULL beendeten Zeichenfolge.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString EnvStr;

EnvStr.GetEnvironmentVariable(_T("TEMP"));
_tprintf_s(_T("Current value of TEMP variable: %s\n"), EnvStr);

CStringT::Insert

Fügt ein einzelnes Zeichen oder eine Teilzeichenfolge am angegebenen Index innerhalb der Zeichenfolge ein.

int Insert(int iIndex, PCXSTR psz);
int Insert(int iIndex, XCHAR ch);

Parameter

iIndex
Der Index des Zeichens, vor dem die Einfügung erfolgt.

psz
Ein Zeiger auf die zu einfügende Teilzeichenfolge.

ch
Das zeichen, das eingefügt werden soll.

Rückgabewert

Die Länge der geänderten Zeichenfolge.

Bemerkungen

Der -Parameter identifiziert das erste Zeichen, das verschoben wird, um Platz für das Zeichen oder die iIndex Teilzeichenfolge zu machen. Wenn nIndex 0 (null) ist, erfolgt die Einfügung vor der gesamten Zeichenfolge. Wenn nIndex höher als die Länge der Zeichenfolge ist, verkettet die Funktion die aktuelle Zeichenfolge und das neue Material, das von oder bereitgestellt psz wird.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str(_T("SoccerBest"));
int n = str.Insert(6, _T("is "));
ASSERT(n == str.GetLength());
_tprintf_s(_T("1: %s\n"), (LPCTSTR) str);

n = str.Insert(6, _T(' '));
ASSERT(n == str.GetLength());
_tprintf_s(_T("2: %s\n"), (LPCTSTR) str);

n = str.Insert(55, _T('!'));
ASSERT(n == str.GetLength());
_tprintf_s(_T("3: %s\n"), (LPCTSTR) str);

CStringT::Left

Extrahiert die am weitesten links angezeigten Zeichen aus diesem -Objekt und gibt nCountCStringT eine Kopie der extrahierten Teilzeichenfolge zurück.

CStringT Left(int nCount) const;

Parameter

nCount
Die Anzahl der aus diesem CStringT-Objekt zu extrahierenden Zeichen.

Rückgabewert

Ein CStringT-Objekt, das eine Kopie des angegebenen Zeichenbereichs enthält. Das zurückgegebene CStringT-Objekt ist ggf. leer.

Bemerkungen

Wenn nCount die Zeichenfolgenlänge überschreitet, wird die gesamte Zeichenfolge extrahiert. Left ähnelt der Left-Funktion von ///Visual Basic.

Bei Multibyte-Zeichensätzen (MULTI-Byte Character Sets, MBCS) behandelt jede 8-Bit-Sequenz als Zeichen, sodass die Anzahl von Multibytezeichen multipliziert mit zwei nCountnCount zurückgegeben wird.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abcdef"));
ASSERT(s.Left(2) == _T("ab"));   

CStringT::LoadString

Liest eine Windows Zeichenfolgenressource, die durch nIDidentifiziert wird, in ein vorhandenes -Objekt.

BOOL LoadString(HINSTANCE hInstance, UINT nID, WORD wLanguageID);
BOOL LoadString(HINSTANCE hInstance, UINT nID);
BOOL LoadString(UINT nID);

Parameter

hInstance
Ein Handle für die Instanz des Moduls.

nID
Eine Windows Zeichenfolgenressourcen-ID.

wLanguageID
Die Sprache der Zeichenfolgenressource.

Rückgabewert

Ungleich 0 (null), wenn das Laden der Ressource erfolgreich war; andernfalls 0.

Bemerkungen

Lädt die Zeichenfolgenressource ( ) aus nID dem angegebenen Modul ( hInstance ) unter Verwendung der angegebenen Sprache ( wLanguage ).

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s;
s.LoadString(IDS_APP_TITLE);   

CStringT::MakeLower

Konvertiert das CStringT -Objekt in eine Zeichenfolge in Kleinbuchstaben.

CStringT& MakeLower();

Rückgabewert

Die resultierende Zeichenfolge in Kleinbuchstaben.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("ABC"));

ASSERT(s.MakeLower() == _T("abc"));   

CStringT::MakeReverse

Kehrt die Reihenfolge der Zeichen im -Objekt CStringT um.

CStringT& MakeReverse();

Rückgabewert

Die resultierende umgekehrte Zeichenfolge.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abc"));

ASSERT(s.MakeReverse() == _T("cba"));   

CStringT::MakeUpper

Konvertiert das CStringT -Objekt in eine Zeichenfolge in Großbuchstaben.

CStringT& MakeUpper();

Rückgabewert

Die resultierende Zeichenfolge in Großbuchstaben.

Bemerkungen

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abc"));

ASSERT(s.MakeUpper() == _T("ABC"));   

CStringT::Mid

Extrahiert eine Teilzeichenfolge von nCount Längenzeichen aus diesem -Objekt, beginnend an der Position CStringTiFirst (nullbasierte).

CStringT Mid(int iFirst, int nCount) const;
CStringT Mid(int iFirst) const;

Parameter

iFirst
Der nullbasierte Index des ersten Zeichens in diesem CStringT Objekt, das in die extrahierte Teilzeichenfolge eingeschlossen werden soll.

nCount
Die Anzahl der aus diesem CStringT-Objekt zu extrahierenden Zeichen. Wenn dieser Parameter nicht angegeben wird, wird der Rest der Zeichenfolge extrahiert.

Rückgabewert

Ein CStringT-Objekt, das eine Kopie des angegebenen Zeichenbereichs enthält. Das zurückgegebene CStringT-Objekt ist ggf. leer.

Bemerkungen

Die Funktion gibt eine Kopie der extrahierten Teilzeichenfolge zurück. Mid ähnelt der Mid-Funktion "Basic" (mit der Ausnahme, dass Indizes in Basic 1-basiert sind).

Bei Multibyte-Zeichensätzen (MBCS) bezieht sich auf jedes 8-Bit-Zeichen, d. h., ein Lead- und ein Nach-Byte in einem Multibytezeichen werden als zwei nCount Zeichen gezählt.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abcdef"));
ASSERT(s.Mid(2, 3) == _T("cde"));   

CStringT::OemToAnsi

Konvertiert alle Zeichen in diesem Objekt aus CStringT dem OEM-Zeichensatz in den ANSI-Zeichensatz.

void OemToAnsi();

Bemerkungen

Diese Funktion ist nicht verfügbar, wenn _UNICODE definiert ist.

Beispiel

Weitere Informationen finden Sie im Beispiel CStringT::AnsiToOem für .

CStringT::operator =

Weist der Zeichenfolge einen neuen Wert zu.

CStringT& operator=(const CStringT& strSrc);

template<bool bMFCDLL>
CStringT& operator=(const CSimpleStringT<BaseType, bMFCDLL>& str);
CStringT& operator=(PCXSTR pszSrc);
CStringT& operator=(PCYSTR pszSrc);
CStringT& operator=(const unsigned char* pszSrc);
CStringT& operator=(XCHAR ch);
CStringT& operator=(YCHAR ch);
CStringT& operator=(const VARIANT& var);

Parameter

strSrc
Ein CStringT , der dieser Zeichenfolge zugewiesen werden soll.

str
Ein Verweis auf ein CThisSimpleString-Objekt.

bMFCDLL
Ein boolescher Wert, der an gibt, ob das Projekt eine MFC-DLL ist oder nicht.

BaseType
Der Zeichenfolgenbasistyp.

var
Ein Variant-Objekt, das dieser Zeichenfolge zugewiesen werden soll.

ch
Ein ANSI- oder Unicode-Zeichen, das der Zeichenfolge zugewiesen werden soll.

pszSrc
Ein Zeiger auf die ursprüngliche Zeichenfolge, die zugewiesen wird.

Bemerkungen

Der Zuweisungsoperator akzeptiert ein CStringT anderes Objekt, einen Zeichenzeiger oder ein einzelnes Zeichen. Speicherausnahmen können immer auftreten, wenn Sie diesen Operator verwenden, da neuer Speicher zugeordnet werden kann.

Informationen zu CThisSimpleString finden Sie im Abschnitt "Hinweise" von CStringT::CStringT .

Hinweis

Obwohl es möglich ist, Instanzen zu erstellen, CStringT die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und CStringT Operatoren für Objekte, die eingebettete NULL-Zeichen enthalten, kann zu unbeabsichtigten Ergebnissen führen.

CStringT::operator +

Verkettet zwei Zeichenfolgen oder ein Zeichen und eine Zeichenfolge.

friend CStringT operator+(const CStringT& str1, const CStringT& str2);
friend CStringT operator+(const CStringT& str1, PCXSTR psz2);
friend CStringT operator+(PCXSTR psz1, const CStringT& str2,);
friend CStringT operator+(char ch1, const CStringT& str2,);
friend CStringT operator+(const CStringT& str1, char ch2);
friend CStringT operator+(const CStringT& str1, wchar_t ch2);
friend CStringT operator+(wchar_t ch1, const CStringT& str2,);

Parameter

ch1
Ein ANSI- oder Unicode-Zeichen, das mit einer Zeichenfolge verkettet werden soll.

ch2
Ein ANSI- oder Unicode-Zeichen, das mit einer Zeichenfolge verkettet werden soll.

str1
Ein CStringT , das mit einer Zeichenfolge oder einem Zeichen verkettet werden soll.

str2
Ein CStringT , das mit einer Zeichenfolge oder einem Zeichen verkettet werden soll.

psz1
Ein Zeiger auf eine auf NULL beendete Zeichenfolge, die mit einer Zeichenfolge oder einem Zeichen verkettet werden soll.

psz2
Ein Zeiger auf eine Zeichenfolge, die mit einer Zeichenfolge oder einem Zeichen verkettet werden soll.

Bemerkungen

Es gibt sieben Überladungsformen der CStringT::operator+ Funktion. Die erste Version verkettet zwei vorhandene CStringT Objekte. Die nächsten beiden verketten ein -Objekt CStringT und eine auf NULL beendete Zeichenfolge. Die nächsten beiden verketten ein CStringT -Objekt und ein ANSI-Zeichen. Die letzten beiden verketten ein CStringT -Objekt und ein Unicode-Zeichen.

Hinweis

Obwohl es möglich ist, Instanzen zu erstellen, CStringT die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und CStringT Operatoren für Objekte, die eingebettete NULL-Zeichen enthalten, kann zu unbeabsichtigten Ergebnissen führen.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("dog ")), s2(_T(" awake")), s3;  // Empty CAtlString objects

s1= _T("The ") + s1;
s3= s1 + _T('i');
s3= s3 + _T('s');
s3= s3 + s2;
ASSERT(s3 == _T("The dog is awake"));   

CStringT::operator +=

Verkettet Zeichen am Ende der Zeichenfolge.

CStringT& operator+=(const CThisSimpleString& str);

template<bool bMFCDLL>
CStringT& operator+=(const const CSimpleStringT<BaseType, bMFCDLL>& str);

template<int t_nSize>
CStringT& operator+=(const CStaticString<XCHAR, t_nSize>& strSrc);
CStringT& operator+=(PCXSTR pszSrc);
CStringT& operator+=(PCYSTR pszSrc);
CStringT& operator+=(char ch);
CStringT& operator+=(unsigned char ch);
CStringT& operator+=(wchar_t ch);
CStringT& operator+=(const VARIANT& var);

Parameter

str
Ein Verweis auf ein CThisSimpleString-Objekt.

bMFCDLL
Ein boolescher Wert, der an gibt, ob das Projekt eine MFC-DLL ist oder nicht.

BaseType
Der Zeichenfolgenbasistyp.

var
Ein Variant-Objekt, das mit dieser Zeichenfolge verkettet werden soll.

ch
Ein ANSI- oder Unicode-Zeichen, das mit einer Zeichenfolge verkettet werden soll.

pszSrc
Ein Zeiger auf die ursprüngliche Zeichenfolge, die verkettet wird.

strSrc
Ein CStringT , das mit dieser Zeichenfolge verkettet werden soll.

Bemerkungen

Der -Operator akzeptiert ein anderes CStringT Objekt, einen Zeichenzeiger oder ein einzelnes Zeichen. Speicherausnahmen können auftreten, wenn Sie diesen Verkettungsoperator verwenden, da für zeichen, die diesem Objekt hinzugefügt werden, neuer Speicher zugeordnet werden CStringT kann.

Informationen zu CThisSimpleString finden Sie im Abschnitt "Hinweise" von CStringT::CStringT .

Hinweis

Obwohl es möglich ist, Instanzen zu erstellen, CStringT die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und CStringT Operatoren für Objekte, die eingebettete NULL-Zeichen enthalten, kann zu unbeabsichtigten Ergebnissen führen.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abc"));
ASSERT((s += _T("def")) == _T("abcdef"));   

CStringT::operator ==

Bestimmt, ob zwei Zeichenfolgen logisch gleich sind.

friend bool operator==(const CStringT& str1, const CStringT& str2) throw();
friend bool operator==(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator==(const CStringT& str1, PCYSTR psz2) throw();
friend bool operator==(const CStringT& str1, XCHAR ch2) throw();
friend bool operator==(PCXSTR psz1, const CStringT& str2) throw();
friend bool operator==(PCYSTR psz1, const CStringT& str2,) throw();
friend bool operator==(XCHAR ch1, const CStringT& str2,) throw();

Parameter

ch1
Ein ANSI- oder Unicode-Zeichen für den Vergleich.

ch2
Ein ANSI- oder Unicode-Zeichen für den Vergleich.

str1
Ein CStringT zum Vergleich.

str2
Ein CStringT zum Vergleich.

psz1
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

psz2
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

Bemerkungen

Testet, ob eine Zeichenfolge oder ein Zeichen auf der linken Seite gleich einer Zeichenfolge oder einem Zeichen auf der rechten Seite ist, und gibt TRUE oder FALSE entsprechend zurück.

Beispiel

// typedef CStringT< TCHAR, StrTraitATL< TCHAR > > CAtlString;
CAtlString s1(_T("dog")), s2(_T("f")), s3(_T("dog"));

ASSERT(s1 == _T("dog"));
ASSERT(s2 == _T('f'));
ASSERT(s1 == s3);   

CStringT::operator !=

Bestimmt, ob zwei Zeichenfolgen logisch nicht gleich sind.

friend bool operator!=(const CStringT& str1, const CStringT& str2) throw();
friend bool operator!=(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator!=(const CStringT& str1, PCYSTR psz2) throw();
friend bool operator!=(const CStringT& str1, XCHAR ch2) throw();
friend bool operator!=(PCXSTR psz1, const CStringT& str2) throw();
friend bool operator!=(PCYSTR psz1, const CStringT& str2,) throw();
friend bool operator!=(XCHAR ch1, const CStringT& str2,) throw();

Parameter

ch1
Ein ANSI- oder Unicode-Zeichen, das mit einer Zeichenfolge verkettet werden soll.

ch2
Ein ANSI- oder Unicode-Zeichen, das mit einer Zeichenfolge verkettet werden soll.

str1
Ein CStringT zum Vergleich.

str2
Ein CStringT zum Vergleich.

psz1
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

psz2
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

Bemerkungen

Testet, ob eine Zeichenfolge oder ein Zeichen auf der linken Seite nicht gleich einer Zeichenfolge oder einem Zeichen auf der rechten Seite ist.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("f")), s3(_T("horse"));

ASSERT(s1 != _T("dog"));
ASSERT(s2 != _T('t'));
ASSERT(s1 != s2);   

CStringT::operator <

Bestimmt, ob die Zeichenfolge links vom Operator kleiner als die Zeichenfolge auf der rechten Seite ist.

friend bool operator<(const CStringT& str1, const CStringT& str2) throw();
friend bool operator<(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator<(PCXSTR psz1, const CStringT& str2) throw();

Parameter

str1
Ein CStringT zum Vergleich.

str2
Ein CStringT zum Vergleich.

psz1
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

psz2
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

Bemerkungen

Ein lexikografischer Vergleich zwischen Zeichenfolgen, Zeichen für Zeichen bis:

  • Er zwei korrespondierende ungleiche Zeichen findet, und deren Vergleich als Ergebnis des Vergleichs zweier Zeichenfolgen genommen wird.

  • Er keine Ungleichheiten findet, aber eine Zeichenfolge mehr Zeichen hat als die andere und die kürzere Zeichenfolge als kleiner als die längere Zeichenfolge betrachtet wird.

  • Er keine Ungleichheiten findet und feststellt, dass die Zeichenfolgen die gleiche Anzahl von Zeichen haben und daher gleich sind.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("cats")), s3(_T("dogs"));

ASSERT(s1 < _T("dog"));
ASSERT(s1 < _T("cats"));
ASSERT(s2 < _T("cats and dogs"));
ASSERT(s2 < s3);   

CStringT::operator >

Bestimmt, ob die Zeichenfolge links vom Operator größer als die Zeichenfolge auf der rechten Seite ist.

friend bool operator>(const CStringT& str1, const CStringT& str2) throw();
friend bool operator>(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator>(PCXSTR psz1, const CStringT& str2) throw();

Parameter

str1
Ein CStringT zum Vergleich.

str2
Ein CStringT zum Vergleich.

psz1
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

psz2
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

Bemerkungen

Ein lexikografischer Vergleich zwischen Zeichenfolgen, Zeichen für Zeichen bis:

  • Er zwei korrespondierende ungleiche Zeichen findet, und deren Vergleich als Ergebnis des Vergleichs zweier Zeichenfolgen genommen wird.

  • Er keine Ungleichheiten findet, aber eine Zeichenfolge mehr Zeichen hat als die andere und die kürzere Zeichenfolge als kleiner als die längere Zeichenfolge betrachtet wird.

  • Er keine Ungleichheiten findet und feststellt, dass die Zeichenfolgen die gleiche Anzahl von Zeichen haben und daher gleich sind.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("cats")), s3(_T("dogs"));
ASSERT(_T("dog") > s1);
ASSERT(_T("cats") > s1);
ASSERT(_T("cats and dogs") > s2);
ASSERT(s3 > s2);   

CStringT::operator <=

Bestimmt, ob die Zeichenfolge links vom Operator kleiner oder gleich der Zeichenfolge rechts vom Operator ist.

friend bool operator<=(const CStringT& str1, const CStringT& str2) throw();
friend bool operator<=(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator<=(PCXSTR psz1, const CStringT& str2) throw();

Parameter

str1
Ein CStringT zum Vergleich.

str2
Ein CStringT zum Vergleich.

psz1
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

psz2
Ein Zeiger auf eine auf NULL beendete Zeichenfolge für den Vergleich.

Bemerkungen

Ein lexikografischer Vergleich zwischen Zeichenfolgen, Zeichen für Zeichen bis:

  • Er zwei korrespondierende ungleiche Zeichen findet, und deren Vergleich als Ergebnis des Vergleichs zweier Zeichenfolgen genommen wird.

  • Er keine Ungleichheiten findet, aber eine Zeichenfolge mehr Zeichen hat als die andere und die kürzere Zeichenfolge als kleiner als die längere Zeichenfolge betrachtet wird.

  • Er keine Ungleichheiten findet und feststellt, dass die Zeichenfolgen die gleiche Anzahl von Zeichen haben und daher gleich sind.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("cats")), s3(_T("dogs"));

ASSERT(s1 <= _T("dog"));
ASSERT(s1 <= _T("cat"));
ASSERT(s3 <= _T("dogs and cats"));
ASSERT(s2 <= s3);   

CStringT::operator >=

Bestimmt, ob die Zeichenfolge links vom Operator größer oder gleich der Zeichenfolge rechts vom Operator ist.

friend bool operator>=(const CStringT& str1, const CStringT& str2) throw();
friend bool operator>=(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator>=(PCXSTR psz1, const CStringT& str2) throw();

Parameter

str1
Ein CStringT zum Vergleich.

str2
Ein CStringT zum Vergleich.

psz1
Ein Zeiger auf eine Zeichenfolge für den Vergleich.

psz2
Ein Zeiger auf eine Zeichenfolge für den Vergleich.

Bemerkungen

Ein lexikografischer Vergleich zwischen Zeichenfolgen, Zeichen für Zeichen bis:

  • Er zwei korrespondierende ungleiche Zeichen findet, und deren Vergleich als Ergebnis des Vergleichs zweier Zeichenfolgen genommen wird.

  • Er keine Ungleichheiten findet, aber eine Zeichenfolge mehr Zeichen hat als die andere und die kürzere Zeichenfolge als kleiner als die längere Zeichenfolge betrachtet wird.

  • Er keine Ungleichheiten findet und feststellt, dass die Zeichenfolgen die gleiche Anzahl von Zeichen haben und daher gleich sind.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("cats")), s3(_T("dogs"));

ASSERT(_T("dog") >= s1);
ASSERT(_T("cats and dogs") >= s2);
ASSERT(s3 >= s2);   

CStringT::Remove

Entfernt alle Instanzen des angegebenen Zeichens aus der Zeichenfolge.

int Remove(XCHAR chRemove);

Parameter

chRemove
Das Zeichen, das aus einer Zeichenfolge entfernt werden soll.

Rückgabewert

Die Anzahl der aus der Zeichenfolge entfernten Zeichen. 0 (null), wenn die Zeichenfolge nicht geändert wird.

Bemerkungen

Bei Vergleichen für das Zeichen wird die Kleinschreibung beachtet.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str(_T("This is a test."));
int n = str.Remove(_T('t'));
ASSERT(n == 2);
ASSERT(str == _T("This is a es."));   

CStringT::Replace

Es gibt zwei Versionen von Replace . Die erste Version ersetzt eine oder mehrere Kopien einer Teilzeichenfolge durch eine andere Teilzeichenfolge. Beide Teilzeichenfolgen werden mit NULL beendet. Die zweite Version ersetzt eine oder mehrere Kopien eines Zeichens durch ein anderes Zeichen. Beide Versionen arbeiten mit den in gespeicherten CStringT Zeichendaten.

int Replace(PCXSTR pszOld, PCXSTR pszNew);
int Replace(XCHAR chOld, XCHAR chNew);

Parameter

pszOld
Ein Zeiger auf eine auf NULL terminierte Zeichenfolge, die durch ersetzt werden pszNew soll.

pszNew
Ein Zeiger auf eine auf NULL beendete Zeichenfolge, die pszOld ersetzt.

chOld
Das Zeichen, das durch ersetzt werden chNew soll.

chNew
Das Zeichen, das chOld ersetzt.

Rückgabewert

Gibt die Anzahl der ersetzten Instanzen des Zeichens oder der Teilzeichenfolge oder null zurück, wenn die Zeichenfolge nicht geändert wird.

Bemerkungen

Replace kann die Zeichenfolgenlänge ändern, da und nicht die gleiche Länge haben müssen und mehrere Kopien der alten Teilzeichenfolge in die pszNewpszOld neue geändert werden können. Die Funktion führt eine Übereinstimmung aus, bei der die Schreibung beachtet wird.

Beispiele für CStringT -Instanzen sind CString , und CStringACStringW .

Für CStringA funktioniert Replace mit ANSI- oder Multibytezeichen (MBCS). Für CStringW funktioniert Replace mit Breitzeichen.

Für wird der Zeichendatentyp zur Kompilierzeit ausgewählt, je nachdem, ob die CString Konstanten in der folgenden Tabelle definiert sind.

Definierte Konstante Character-Datentyp
_UNICODE Breitzeichen
_MBCS Multi-Byte-Zeichen
Neither Einzel bytezeichen
Beide Nicht definiert

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString strBang(_T("Everybody likes epee fencing"));
int n = strBang.Replace(_T("epee"), _T("foil"));
ASSERT(n == 1);   

CStringT::ReverseFind

Durchsucht CStringT dieses Objekt nach der letzten Übereinstimmung eines Zeichens.

int ReverseFind(XCHAR ch) const throw();

Parameter

ch
Das zu suchde Zeichen.

Rückgabewert

Der nullbasierte Index des letzten Zeichens in diesem Objekt, das dem angeforderten Zeichen entspricht, oder -1, wenn das Zeichen CStringT nicht gefunden wird.

Bemerkungen

Die Funktion ähnelt der Laufzeitfunktion strrchr .

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abcabc"));
ASSERT(s.ReverseFind(_T('b')) == 4);   

Extrahiert die letzten Zeichen (d. h. am weitesten rechts) aus diesem -Objekt und gibt eine Kopie der extrahierten nCountCStringT Teilzeichenfolge zurück.

CStringT Right(int nCount) const;

Parameter

nCount
Die Anzahl der aus diesem CStringT-Objekt zu extrahierenden Zeichen.

Rückgabewert

Ein CStringT-Objekt, das eine Kopie des angegebenen Zeichenbereichs enthält. Das CStringT zurückgegebene Objekt kann leer sein.

Bemerkungen

Wenn nCount die Zeichenfolgenlänge überschreitet, wird die gesamte Zeichenfolge extrahiert. Right ähnelt der Right Basic-Funktion (mit der Ausnahme, dass Indizes in Basic null-basiert sind).

Bei Multibyte-Zeichensätzen ( ) bezieht sich auf jedes MBCS 8-Bit-Zeichen, d. h. ein Lead- und ein nach trail-Byte in einem nCount Multibytezeichen werden als zwei Zeichen gezählt.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString s(_T("abcdef"));
ASSERT(s.Right(2) == _T("ef"));   

CStringT::SetSysString

Weist die neu zu, auf die von gezeigt wird, und kopiert den Inhalt des BSTRpbstrCStringT Objekts, einschließlich des NULL Zeichens, in das Objekt.

BSTR SetSysString(BSTR* pbstr) const;

Parameter

pbstr
Ein Zeiger auf eine Zeichenfolge.

Rückgabewert

Die neue Zeichenfolge.

Bemerkungen

Abhängig vom Inhalt des -Objekts CStringT kann sich der Wert der ändern, auf die von verwiesen BSTRpbstr wird. Die Funktion löst eine aus, CMemoryException wenn nicht genügend Arbeitsspeicher vorhanden ist.

Diese Funktion wird normalerweise verwendet, um den Wert von Zeichenfolgen zu ändern, die als Verweis für Automation übergeben werden.

Beispiel

BSTR bstr = ::SysAllocString(L"Golf is fun!");

// create a CAtlString and change the OLE
// string to the contents of the BSTR
// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str(_T("Soccer is best!"));
BSTR bstr2 = str.SetSysString(&bstr);

// Now, both bstr and bstr2 reference a single instance of
// the "Soccer" string. The "Golf" string has been freed.
ASSERT(bstr2 == bstr);   

CStringT::SpanExcluding

Extrahiert Zeichen aus der Zeichenfolge, beginnend mit dem ersten Zeichen, die sich nicht in dem durch identifizierten Zeichensatz pszCharSet befinden.

CStringT SpanExcluding(PCXSTR pszCharSet) const;

Parameter

pszCharSet
Eine Zeichenfolge, die als Zeichensatz interpretiert wird.

Rückgabewert

Eine Teilzeichenfolge, die Zeichen in der Zeichenfolge enthält, die nicht in enthalten sind, beginnend mit dem ersten Zeichen in der Zeichenfolge und endend mit dem ersten Zeichen in der Zeichenfolge, das sich ebenfalls in befindet (d. h. beginnend mit dem ersten Zeichen in der Zeichenfolge und bis zum ersten Zeichen in der gefundenen Zeichenfolge, aber pszCharSetpszCharSetpszCharSet ausschließlich). Sie gibt die gesamte Zeichenfolge zurück, wenn kein Zeichen in pszCharSet der Zeichenfolge gefunden wird.

Bemerkungen

SpanExcluding extrahiert und gibt alle Zeichen vor dem ersten Vorkommen eines Zeichens aus zurück (d. h., das Zeichen aus und alle Zeichen, die in der Zeichenfolge darauf pszCharSetpszCharSet folgen, werden nicht zurückgegeben). Wenn in der pszCharSet Zeichenfolge kein Zeichen von gefunden wird, wird SpanExcluding die gesamte Zeichenfolge zurückgegeben.

Beispiel

// The string can be delimited by a semicolon(;),
//  a comma(,), a period(.), a dash(-),
// or an apostrophe(').
// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString src(_T("World Cup '98"));

_tprintf_s(_T("%s"),src.SpanExcluding(_T(";,.-'")));

CStringT::SpanIncluding

Extrahiert Zeichen aus der Zeichenfolge, beginnend mit dem ersten Zeichen, die sich in dem Satz von Zeichen befinden, die durch identifiziert pszCharSet werden.

CStringT SpanIncluding(PCXSTR pszCharSet) const;

Parameter

pszCharSet
Eine Zeichenfolge, die als Zeichensatz interpretiert wird.

Rückgabewert

Eine Teilzeichenfolge, die Zeichen in der Zeichenfolge enthält, die sich in befinden, beginnend mit dem ersten Zeichen in der Zeichenfolge und endend, wenn ein Zeichen in der Zeichenfolge gefunden wird, die sich nicht pszCharSet in pszCharSet befindet. SpanIncluding gibt eine leere Teilzeichenfolge zurück, wenn sich das erste Zeichen in der Zeichenfolge nicht im angegebenen Satz befindet.

Bemerkungen

Wenn das erste Zeichen der Zeichenfolge nicht im Zeichensatz enthalten ist, gibt SpanIncluding eine leere Zeichenfolge zurück. Andernfalls wird eine Sequenz von aufeinander folgenden Zeichen zurückgegeben, die sich in der Gruppe befinden.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str(_T("cabbage"));
CAtlString res = str.SpanIncluding(_T("abc"));
ASSERT(res == _T("cabba"));
res = str.SpanIncluding(_T("xyz"));
ASSERT(res.IsEmpty());   

CStringT::Tokenize

Sucht das nächste Token in einer Zielzeichenfolge.

CStringT Tokenize(PCXSTR pszTokens, int& iStart) const;

Parameter

pszTokens
Eine Zeichenfolge, die Tokentrennzeichen enthält. Die Reihenfolge dieser Trennzeichen ist nicht wichtig.

iStart
Der nullbasierte Index, mit dem die Suche begonnen werden soll.

Rückgabewert

Ein CStringT -Objekt, das den aktuellen Tokenwert enthält.

Bemerkungen

Die Tokenize Funktion sucht das nächste Token in der Zielzeichenfolge. Der Zeichensatz in pszTokens gibt mögliche Trennzeichen des zu findenden Tokens an. Bei jedem Aufruf der Funktion beginnt bei , überspringt führende Trennzeichen und gibt ein -Objekt zurück, das das aktuelle Token enthält, bei dem es sich um die Zeichenfolge bis zum nächsten TokenizeiStartCStringT Trennzeichen handelt. Der Wert von wird aktualisiert, um die Position nach dem Endtrennzeichen zu sein, oder -1, wenn das Ende der Zeichenfolge iStart erreicht wurde. Weitere Token können aus dem Rest der Zielzeichenfolge durch eine Reihe von Aufrufen von unterbrochen werden. Verwenden Sie , um nachzugeben, wo in der Zeichenfolge das nächste Token TokenizeiStart gelesen werden soll. Wenn keine Token mehr enthalten sind, gibt die Funktion eine leere Zeichenfolge zurück und iStart wird auf -1 festgelegt.

Im Gegensatz zu den CRT-Tokenisierungsfunktionen wie , , , _strtok_s_l , wcstok_s_wcstok_s_l_mbstok_s , _mbstok_s_lwird Tokenize die Zielzeichenfolge nicht geändert.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString str(_T("%First Second#Third"));
CAtlString resToken;
int curPos = 0;

resToken= str.Tokenize(_T("% #"),curPos);
while (resToken != _T(""))
{
   _tprintf_s(_T("Resulting token: %s\n"), resToken);
   resToken = str.Tokenize(_T("% #"), curPos);
};   

Die Ausgabe dieses Beispiels lautet wie folgt:

Resulting Token: First
Resulting Token: Second
Resulting Token: Third

CStringT::Trim

Entfernt führende und nachrangende Zeichen aus der Zeichenfolge.

CStringT& Trim(XCHAR chTarget);
CStringT& Trim(PCXSTR pszTargets);
CStringT& Trim();

Parameter

chTarget
Das zu kürzende Zielzeichen.

pszTargets
Ein Zeiger auf eine Zeichenfolge, die die zu kürzenden Zielzeichen enthält. Alle führenden und nachkommaenden Vorkommen von Zeichen in pszTargets werden aus dem -Objekt CStringT entfernt.

Rückgabewert

Gibt die gekürzte Zeichenfolge zurück.

Bemerkungen

Entfernt alle führenden und nachfolgenden Vorkommen eines der folgenden:

  • Das von angegebene chTarget Zeichen.

  • Alle Zeichen, die in der durch angegebenen Zeichenfolge gefunden pszTargets werden.

  • Leerzeichen.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str;
str = _T("******Soccer is best!?!?!?!?!");

_tprintf_s(_T("Before: \"%s\"\n"), (LPCTSTR)str);
_tprintf_s(_T("After : \"%s\"\n"), (LPCTSTR)str.Trim(_T("?!*")));

// Output:
// --------------------------
// Before: ******Soccer is best!?!?!?!?!
// After: Soccer is best

Die Ausgabe dieses Beispiels lautet wie folgt:

Before: "******Soccer is best, but liquor is quicker!!!!!"
After : "Soccer is best, but liquor is quicker"

CStringT::TrimLeft

Entfernt führende Zeichen aus der Zeichenfolge.

CStringT& TrimLeft(XCHAR chTarget);
CStringT& TrimLeft(PCXSTR pszTargets);
CStringT& TrimLeft();

Parameter

chTarget
Das zu kürzende Zielzeichen.

pszTargets
Ein Zeiger auf eine Zeichenfolge, die die zu kürzenden Zielzeichen enthält. Alle führenden Vorkommen von Zeichen in pszTargets werden aus dem -Objekt CStringT entfernt.

Rückgabewert

Die resultierende gekürzte Zeichenfolge.

Bemerkungen

Entfernt alle führenden und nachfolgenden Vorkommen eines der folgenden:

  • Das von angegebene chTarget Zeichen.

  • Alle Zeichen, die in der durch angegebenen Zeichenfolge gefunden pszTargets werden.

  • Leerzeichen.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str;
str = _T("\t\t   ****Soccer is best!");

_tprintf_s(_T("Before: \"%s\"\n"), (LPCTSTR)str);
_tprintf_s(_T("After: \"%s\"\n"), (LPCTSTR)str.TrimLeft(_T("\t *")));

// Output:
// --------------------------
// Before:     ****Soccer is best!
// After: Soccer is best!

CStringT::TrimRight

Entfernt nachrangende Zeichen aus der Zeichenfolge.

CStringT& TrimRight(XCHAR chTarget);
CStringT& TrimRight(PCXSTR pszTargets);
CStringT& TrimRight();

Parameter

chTarget
Das zu kürzende Zielzeichen.

pszTargets
Ein Zeiger auf eine Zeichenfolge, die die zu kürzenden Zielzeichen enthält. Alle nachkommaenden Vorkommen von Zeichen in pszTargets werden aus dem -Objekt CStringT entfernt.

Rückgabewert

Gibt das CStringT -Objekt zurück, das die gekürzte Zeichenfolge enthält.

Bemerkungen

Entfernt nachfolgende Vorkommen einer der folgenden:

  • Das von angegebene chTarget Zeichen.

  • Alle Zeichen, die in der durch angegebenen Zeichenfolge gefunden pszTargets werden.

  • Leerzeichen.

Die Version akzeptiert einen Zeichenparameter und entfernt alle Kopien dieses CStringT& TrimRight(XCHAR chTarget) Zeichens am Ende der CStringT Zeichenfolgendaten. Er beginnt am Ende der Zeichenfolge und arbeitet bis zum Anfang. Sie wird beendet, wenn ein anderes Zeichen gefunden wird oder CStringT wenn keine Zeichendaten mehr enthalten sind.

Die CStringT& TrimRight(PCXSTR pszTargets) Version akzeptiert eine auf NULL beendete Zeichenfolge, die alle verschiedenen zu suchden Zeichen enthält. Er entfernt alle Kopien dieser Zeichen im CStringT -Objekt. Er beginnt am Ende der Zeichenfolge und arbeitet in Richtung des Front-End-Werts. Er wird beendet, wenn ein Zeichen gefunden wird, das nicht in der Zielzeichenfolge enthalten ist, oder wenn keine CStringT Zeichendaten mehr enthalten sind. Es wird nicht versucht, die gesamte Zielzeichenfolge mit einer Teilzeichenfolge am Ende von zu CStringT verketten.

Die CStringT& TrimRight() Version erfordert keine Parameter. Es entfernt alle nachhinaufenden Leerzeichen am Ende der CStringT Zeichenfolge. Leerzeichen können Zeilenumbrüche, Leerzeichen oder Registerkarten sein.

Beispiel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str;
str = _T("Soccer is best!?!?!?!?!");

_tprintf_s(_T("Before: \"%s\"\n"), (LPCTSTR)str);
_tprintf_s(_T("After : \"%s\"\n"), (LPCTSTR)str.TrimRight(_T("?!")));

// Output:
// --------------------------
// Before: Soccer is best!?!?!?!?!
// After: Soccer is best

Siehe auch

Hierarchiediagramm
Freigegebene ATL/MFC-Klassen
Klasse