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 m_hInstResource angegebenen Modul (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 m_hInstResource angegebenen Modul (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 bezieht sprintf .
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 pszCharSetidentifizierten Zeichensatz 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 CStringT neuen Wert 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.

Hinweise

CStringTerbt von derCSimpleStringT -Klasse. Erweiterte Features, z. B. Zeichenbearbeitung, Sortierung und Suche, werden von CStringTimplementiert.

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 die CStringT Verwendung von Objekten als normale Zeichenarrays.

Hinweis

Obwohl es möglich ist, Instanzen zu erstellen CStringT , 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 CStringT und StringTraits können Objekte in den folgenden Typen enthalten sein, die von den ATL-Bibliotheken vordefiniert wurden.

Bei Verwendung in einer ATL-Anwendung:

CString, CStringAund CStringW werden aus der 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 CStringT beschrieben 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 ZEICHENFOLGE des ANSI-Zeichentyps 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, in denen ATL_CSTRING_NO_CRT nicht definiert ist:

CStringT-Typ	Deklaration
CAtlStringA	Eine ZEICHENFOLGE vom Typ ANSI 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 weisen außerdem die folgenden Merkmale auf:

• CStringT -Objekte können aufgrund von Verkettungsvorgängen vergrößert werden.

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

• Sie können Objekte frei durch PCXSTR Funktionsargumente ersetzenCStringT.

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

Vordefinierte CStringT-Typen

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

Name	BESCHREIBUNG
XCHAR	Ein einzelnes Zeichen (entweder wchar_t oder char) mit demselben Zeichentyp wie das CStringT -Objekt.
YCHAR	Ein einzelnes Zeichen (entweder wchar_t oder char) mit dem 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 char) mit dem entgegengesetzten Zeichentyp als CStringT -Objekt.
PCXSTR	Ein Zeiger auf eine const Zeichenfolge (entweder wchar_t oder char) mit demselben Zeichentyp wie das CStringT -Objekt.
PCYSTR	Ein Zeiger auf eine const Zeichenfolge (entweder wchar_t oder char) mit dem entgegengesetzten Zeichentyp als CStringT -Objekt.

Hinweis

Code, der zuvor nicht dokumentierte Methoden von CString (z AssignCopy. B. ) verwendet hat, muss durch Code ersetzt werden, der die folgenden dokumentierten Methoden von CStringT verwendet (z GetBuffer . B. oder ReleaseBuffer). Diese Methoden werden von CSimpleStringTgeerbt.

Vererbungshierarchie

CSimpleStringT

CStringT

Anforderungen

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

CStringT::AllocSysString

Ordnet eine Automation-kompatible Zeichenfolge des Typs BSTR zu und kopiert den Inhalt des CStringT Objekts in diese, einschließlich des abschließenden NULL-Zeichens.

BSTR AllocSysString() const;

Rückgabewert

Die neu zugeordnete Zeichenfolge.

Hinweise

In MFC-Programmen wird eine CMemoryException Klasse ausgelöst, wenn nicht genügend Arbeitsspeicher vorhanden ist. In ATL-Programmen wird eine CAtlException ausgelöst. Diese Funktion wird normalerweise verwendet, um Zeichenfolgen für Automation zurückzugeben.

Wenn diese Zeichenfolge als [in] Parameter an eine COM-Funktion übergeben wird, erfordert dies in der Regel, dass der Aufrufer die Zeichenfolge frei gibt. Dies kann mithilfe SysFreeStringvon erfolgen, wie im Windows SDK beschrieben. Weitere Informationen finden Sie unter Zuordnen und Freigeben von Arbeitsspeicher für eine BSTR.

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 CStringT Objekt aus dem ANSI-Zeichensatz in den OEM-Zeichensatz.

void AnsiToOem();

Hinweise

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 CStringT Objekt an.

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

Parameter

pszFormat
Eine Formatsteuerelementzeichenfolge.

nFormatID
Der Zeichenfolgenressourcenbezeichner, der die Formatsteuerelementzeichenfolge enthält.

argument
Optionale Argumente.

Hinweise

Diese Funktion formatiert und fügt eine Reihe von Zeichen und Werten in der an CStringT. Jedes optionale Argument (sofern vorhanden) wird gemäß der entsprechenden Formatspezifikation in pszFormat oder aus der durch nFormatIDidentifizierten Zeichenfolgenressource konvertiert und 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 CStringT Objekt kleiner als pszist, oder > 0, wenn dieses CStringT Objekt größer als pszist.

Hinweise

Die generische Textfunktion _tcscoll, die in TCHAR.Hdefiniert ist, wird je nach dem Zeichensatz, der zur Kompilierzeit definiert wird, entweder strcoll, wcscolloder _mbscollzugeordnet. Jede Funktion führt einen Vergleich der Zeichenfolgen entsprechend der aktuell verwendeten Codepage durch, bei der die Groß-/Kleinschreibung beachtet wird. Weitere Informationen finden Sie unter strcoll, 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ßschreibung wird ignoriert), < 0, wenn dieses CStringT Objekt kleiner als psz ist (groß-/großschreibung wird ignoriert) oder > 0, wenn dieses CStringT Objekt größer als psz ist (großschreibung wird ignoriert).

Hinweise

Die generische Textfunktion _tcscoll, die in TCHAR.Hdefiniert ist, wird je nach dem Zeichensatz, der zur Kompilierzeit definiert wird, entweder stricoll, wcsicolloder _mbsicollzugeordnet. Jede Funktion vergleicht die Zeichenfolgen entsprechend der aktuell verwendeten Codepage ohne Unterscheidung nach Groß-/Kleinschreibung. Weitere Informationen finden Sie unter strcoll, 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 (Groß-/Kleinschreibung wird beachtet).

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 CStringT Objekt kleiner als pszist, oder > 0, wenn dieses CStringT Objekt größer als pszist.

Hinweise

Die generische Textfunktion _tcscmp, die in TCHAR.Hdefiniert ist, wird je nach dem Zeichensatz, der zur Kompilierzeit definiert wird, entweder strcmp, wcscmpoder _mbscmpzugeordnet. Jede Funktion führt einen Vergleich der Zeichenfolgen durch, bei dem die Groß-/Kleinschreibung beachtet wird, und ist nicht vom Gebietsschema betroffen. Weitere Informationen finden Sie unter strcmp, wcscmp, _mbscmp.

Wenn die Zeichenfolge eingebettete NULL-Werte enthält, wird die Zeichenfolge zu Vergleichszwecken 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 Unterscheidung nach 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ßschreibung wird ignoriert), <0, wenn dieses CStringT Objekt kleiner als psz ist (groß-/großschreibung wird ignoriert) oder >0, wenn dieses CStringT Objekt größer als psz ist (großschreibung wird ignoriert).

Hinweise

Die generische Textfunktion _tcsicmp, die in TCHAR.Hdefiniert ist, _stricmp_wcsicmp_mbsicmpwird abhängig vom zeichenbasierten Satz, der zur Kompilierzeit definiert ist, entweder oder zu - oder -Zeichensatz. Jede Funktion führt einen Vergleich der Zeichenfolgen durch, bei dem die Groß-/Kleinschreibung nicht beachtet wird. Der Vergleich hängt vom Aspekt des LC_CTYPE -Locale ab, aber nicht vom -Aspekt LC_COLLATE. Weitere Informationen finden Sie unter _stricmp, _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 - und IAtlStringMgr -Speicherverwaltung für finden CStringTSie unter Speicherverwaltung mit CStringT.

strSrc
Ein vorhandenes CStringT Objekt, das in dieses Objekt kopiert werden CStringT soll. Weitere Informationen zu und CThisString finden CThisSimpleStringSie im Abschnitt "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 sein System::String, und das Projekt muss mit kompiliert werden /clr.

pString
Ein Handle für ein CStringT -Objekt.

Hinweise

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, bei LPTSTR 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 einer CStringT Unicode-Zeichenfolge.

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

Hinweis

Definieren Sie das Makro _CSTRING_DISABLE_NARROW_WIDE_CONVERSION , 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 ein CStringT -Objekt CThisSimpleString sein. Verwenden CStringTSie für eine der Standard instanziierungen (CString, CStringAoder CStringW); CThisSimpleStringfür , verwenden Sie einen this -Zeiger. CThisSimpleStringdeklariert eine Instanz der -KlasseCSimpleStringT, bei der es sich um eine kleinere Zeichenfolgenklasse mit weniger integrierten Funktionen als die -Klasse CStringT handelt.

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

Hinweis

Obwohl es möglich ist, Instanzen zu CStringT erstellen, die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und Operatoren CStringT 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();

Hinweise

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 zu löschenden CStringT Objekt.

nCount
Die Anzahl der zu entfernenden Zeichen.

Rückgabewert

Die Länge der geänderten Zeichenfolge.

Hinweise

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 CStringT diesem Objekt, das der angeforderten Teilzeichenfolge oder den angeforderten Zeichen entspricht; -1, wenn die Teilzeichenfolge oder das Zeichen nicht gefunden wird.

Hinweise

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

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 entspricht pszCharSet.

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 pszCharSetbefindet; -1, wenn keine Übereinstimmung vorgibt.

Hinweise

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 sprintf_s Daten in ein 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.

Hinweise

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 pszFormat oder aus der durch identifizierten Zeichenfolgenressource konvertiert und ausgegeben nFormatID.

Der Aufruf ist nicht möglich, wenn das Zeichenfolgenobjekt selbst als Parameter für angeboten wird Format. 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 Syntax der Formatspezifikation: printf 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 printfim Laufzeitfunktionsformat, mit der Ausnahme, dass die Parameter in beliebiger Reihenfolge eingefügt werden können.

argument
Optionale Argumente.

Hinweise

Die Funktion erfordert eine Nachrichtendefinition als Eingabe. Die Nachrichtendefinition wird durch oder von pszFormat der Zeichenfolgenressource bestimmt, die durch identifiziert wird nFormatID. Die Funktion kopiert den formatierten Meldungstext in das -Objekt CStringT und verarbeitet bei Anfrage 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 dem pszFormat -Parameter nFormatID haben. Innerhalb des Nachrichtentexts werden mehrere Escapesequenzen unterstützt, um die Nachricht dynamisch zu formatieren. Weitere Informationen finden Sie in der Windows-Funktion FormatMessage 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 Nachrichtenzeichenfolge mithilfe einer Variablenargumentliste.

void FormatMessageV(PCXSTR pszFormat, va_list* pArgList);

Parameter

pszFormat
Zeigt auf die Formatsteuerelementzeichenfolge. Sie wird auf Einfügungen überprüft und entsprechend formatiert. Die Formatzeichenfolge ähnelt Formatzeichenfolgen der Laufzeitfunktion printfim Format , mit der Ausnahme, dass die Parameter in einer beliebigen Reihenfolge eingefügt werden können.

pArgList
Zeiger auf eine Liste von Argumenten.

Hinweise

Die Funktion erfordert eine Nachrichtendefinition als Eingabe, die durch bestimmt wird pszFormat. Die Funktion kopiert den formatierten Nachrichtentext und eine Variablenliste von Argumenten in das CStringT -Objekt und verarbeitet ggf. eingebettete Einfügesequenzen.

Hinweis

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

Weitere Informationen finden Sie in der Windows-Funktion FormatMessage im Windows SDK.

CStringT::FormatV

Formatiert eine Nachrichtenzeichenfolge mithilfe einer Variablenargumentliste.

void FormatV(PCXSTR pszFormat, va_list args);

Parameter

pszFormat
Zeigt auf die Formatsteuerelementzeichenfolge. Sie wird auf Einfügungen überprüft und entsprechend formatiert. Die Formatzeichenfolge ähnelt Formatzeichenfolgen der Laufzeitfunktion printfim Format , mit der Ausnahme, dass die Parameter in einer beliebigen Reihenfolge eingefügt werden können.

args
Zeiger auf eine Liste von Argumenten.

Hinweise

Schreibt eine formatierte Zeichenfolge und eine Variablenliste von Argumenten auf die gleiche Weise in eine CStringT Zeichenfolge, die vsprintf_s Daten in ein 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 endende Zeichenfolge, die die Umgebungsvariable angibt.

Rückgabewert

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

Hinweise

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

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 einzufügende Teilzeichenfolge.

ch
Das einzufügende Zeichen.

Rückgabewert

Die Länge der geänderten Zeichenfolge.

Hinweise

Der iIndex -Parameter identifiziert das erste Zeichen, das verschoben wird, um Platz für das Zeichen oder die Teilzeichenfolge zu schaffen. 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 chpszbereitgestellt 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 nCount links liegenden Zeichen aus diesem CStringT Objekt und gibt 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.

Hinweise

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

Behandelt für Multibyte-Zeichensätze (MBCS) nCount jede 8-Bit-Sequenz als Zeichen, sodass nCount die Anzahl von Multibytezeichen multipliziert mit zwei zurückgibt.

Beispiel

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

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

CStringT::LoadString

Liest eine durch nID identifizierte Windows Zeichenfolgenressource in ein vorhandenes CStringT 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.

Hinweise

Lädt die Zeichenfolgenressource (nID) aus dem angegebenen Modul (hInstance) mit 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 um CStringT .

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 Längenzeichen nCount aus diesem CStringT Objekt, beginnend an der Position iFirst (nullbasiert).

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.

Hinweise

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

Für Multibyte-Zeichensätze (MBCS) nCount bezieht sich auf jedes 8-Bit-Zeichen, d. h., ein Lead- und ein nachfolgendes Byte in einem Multibytezeichen werden als zwei 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 CStringT Objekt aus dem OEM-Zeichensatz in den ANSI-Zeichensatz.

void OemToAnsi();

Hinweise

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

Beispiel

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

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.

Hinweise

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

Informationen zu finden CThisSimpleStringSie im Abschnitt "Hinweise" von CStringT::CStringT.

Hinweis

Obwohl es möglich ist, Instanzen zu CStringT erstellen, die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und Operatoren CStringT 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.

Hinweise

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

Hinweis

Obwohl es möglich ist, Instanzen zu CStringT erstellen, die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und Operatoren CStringT 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.

Hinweise

Der -Operator akzeptiert ein anderes Objekt CStringT , 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 finden CThisSimpleStringSie im Abschnitt "Hinweise" von CStringT::CStringT.

Hinweis

Obwohl es möglich ist, Instanzen zu CStringT erstellen, die eingebettete NULL-Zeichen enthalten, wird dagegen empfohlen. Das Aufrufen von Methoden und Operatoren CStringT 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 zum CStringT Vergleich.

str2
Ein zum CStringT 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.

Hinweise

Testet, ob eine Zeichenfolge oder ein Zeichen auf der linken Seite gleich einer Zeichenfolge oder einem Zeichen auf der rechten Seite ist, und gibt oder TRUE entsprechend FALSE 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 zum CStringT Vergleich.

str2
Ein zum CStringT 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.

Hinweise

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 zum CStringT Vergleich.

str2
Ein zum CStringT 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.

Hinweise

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 zum CStringT Vergleich.

str2
Ein zum CStringT 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.

Hinweise

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 zum CStringT Vergleich.

str2
Ein zum CStringT Vergleich.

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

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

Hinweise

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 für den Vergleich.

str2
Ein CStringT für den Vergleich.

psz1
Ein Zeiger auf eine Zeichenfolge zum Vergleich.

psz2
Ein Zeiger auf eine Zeichenfolge zum Vergleich.

Hinweise

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.

Hinweise

Bei Vergleichen für das Zeichen wird die Groß-/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 sind NULL-terminiert. Die zweite Version ersetzt eine oder mehrere Kopien eines Zeichens durch ein anderes Zeichen. Beide Versionen arbeiten mit den in CStringTgespeicherten Zeichendaten.

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

Parameter

pszOld
Ein Zeiger auf eine auf NULL endende Zeichenfolge, die durch pszNewersetzt werden soll.

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

chOld
Das Zeichen, das durch chNewersetzt werden soll.

chNew
Das Zeichen, das ersetzt chOld.

Rückgabewert

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

Hinweise

Replace kann die Zeichenfolgenlänge ändern, da pszNew und pszOld nicht dieselbe Länge aufweisen müssen und mehrere Kopien der alten Teilzeichenfolge in die neue geändert werden können. Die Funktion führt eine Übereinstimmung aus, bei der die Groß-/Kleinschreibung beachtet wird.

Beispiele für CStringT Instanzen sind CString, CStringAund CStringW.

Replace Für CStringAkann mit ANSI- oder Multibytezeichen (MBCS) verwendet werden. Replace Für CStringWfunktioniert mit Breitzeichen.

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

Definierte Konstante	Zeichendatentyp
_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 dieses CStringT Objekt nach der letzten Übereinstimmung eines Zeichens.

int ReverseFind(XCHAR ch) const throw();

Parameter

ch
Das zu suchende Zeichen.

Rückgabewert

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

Hinweise

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);   

CStringT::Right

Extrahiert die letzten (ganz rechts) nCount Zeichen aus diesem CStringT Objekt und gibt eine Kopie der extrahierten 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 zurückgegebene CStringT Objekt kann leer sein.

Hinweise

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

Bei Multibyte-Zeichensätzen (MBCS) nCount bezieht sich auf jedes 8-Bit-Zeichen, d. h., ein Lead- und ein nachfolgendes Byte in einem 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 den neu zu, auf den BSTR von gezeigt wird pbstr , und kopiert den Inhalt des CStringT Objekts einschließlich des NULL Zeichens hinein.

BSTR SetSysString(BSTR* pbstr) const;

Parameter

pbstr
Ein Zeiger auf eine Zeichenfolge.

Rückgabewert

Die neue Zeichenfolge.

Hinweise

Abhängig vom Inhalt des CStringT -Objekts kann sich der Wert der ändern, auf die BSTR von verwiesen wird pbstr . Die Funktion löst eine CMemoryException aus, 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 pszCharSetidentifizierten Zeichensatz 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 sich nicht in pszCharSetbefinden, beginnend mit dem ersten Zeichen in der Zeichenfolge und mit dem ersten Zeichen in der Zeichenfolge enden, das sich ebenfalls in pszCharSet befindet (d.amp;quot;, beginnend mit dem ersten Zeichen in der Zeichenfolge und bis zum Ausschließen des ersten Zeichens in der gefundenen pszCharSetZeichenfolge). Sie gibt die gesamte Zeichenfolge zurück, wenn kein Zeichen in pszCharSet in der Zeichenfolge gefunden wird.

Hinweise

SpanExcluding extrahiert und gibt alle Zeichen vor dem ersten Vorkommen eines Zeichens aus pszCharSet zurück (d. h. das Zeichen von pszCharSet und alle Zeichen, die in der Zeichenfolge darauf folgen, werden nicht zurückgegeben). Wenn in der Zeichenfolge kein Zeichen von pszCharSet gefunden wird, SpanExcluding wird 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 durch pszCharSetidentifizierten Zeichensatz befinden.

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 pszCharSetbefinden, beginnend mit dem ersten Zeichen in der Zeichenfolge und enden, wenn ein Zeichen in der Zeichenfolge gefunden wird, die sich nicht in pszCharSetbefindet. SpanIncluding gibt eine leere Teilzeichenfolge zurück, wenn sich das erste Zeichen in der Zeichenfolge nicht im angegebenen Satz befindet.

Hinweise

Wenn das erste Zeichen der Zeichenfolge nicht im Zeichensatz enthalten ist, SpanIncluding gibt 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.

Hinweise

Die Tokenize Funktion sucht das nächste Token in der Zielzeichenfolge. Der Zeichensatz in gibt pszTokens mögliche Trennzeichen des zu findenden Tokens an. Bei jedem TokenizeiStartAufruf der Funktion beginnt bei , überspringt führende Trennzeichen und gibt ein -Objekt zurück, CStringT das das aktuelle Token enthält, bei dem es sich um die Zeichenfolge bis zum nächsten Trennzeichen handelt. Der Wert von iStart wird aktualisiert, um die Position nach dem Endtrennzeichen zu sein, oder -1, wenn das Ende der Zeichenfolge erreicht wurde. Weitere Token können aus Tokenizedem Rest der Zielzeichenfolge durch eine Reihe von Aufrufen von unterbrochen werden. Verwenden Sie , iStart um nachzugeben, wo in der Zeichenfolge das nächste Token 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 strtok_swie , _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 entfernt CStringT .

Rückgabewert

Gibt die gekürzte Zeichenfolge zurück.

Hinweise

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

• Das von angegebene Zeichen chTarget.

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

• 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.

Hinweise

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

• Das von angegebene Zeichen chTarget.

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

• 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.

Hinweise

Entfernt nachfolgende Vorkommen einer der folgenden:

• Das von angegebene Zeichen chTarget.

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

• Leerzeichen.

Die CStringT& TrimRight(XCHAR chTarget) Version akzeptiert einen Zeichenparameter und entfernt alle Kopien dieses Zeichens am Ende der Zeichenfolgendaten CStringT . 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, CStringT oder wenn keine Zeichendaten mehr enthalten sind. Es wird nicht versucht, die gesamte Zielzeichenfolge mit einer Teilzeichenfolge am Ende von zu verketten CStringT.

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
CSimpleStringT Klasse