`CStringT`-Klasse

Artikel
04/03/2023

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 (sowohl für ANSI- als auch für Unicode-Zeichenzeichenfolgen).

StringTraits
Bestimmt, ob die Zeichenfolgenklasse C Run-Time (CRT)-Bibliothek unterstützt 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>>

Für die Klasse ist CRT-Unterstützung erforderlich, und es wird nach Ressourcenzeichenfolgen im angegebenen m_hInstResource Modul gesucht (ein Element der Modulklasse der Anwendung).
StrTraitATL<wchar_t | char | TCHAR, ChTraitsOS<wchar_t | char |TCHAR>>

Für die Klasse ist keine CRT-Unterstützung erforderlich, und es wird nach Ressourcenzeichenfolgen im angegebenen m_hInstResource Modul gesucht (ein Element der Modulklasse der Anwendung).
StrTraitMFC<wchar_t | char | TCHAR, ChTraitsCRT<wchar_t | char | TCHAR>>

Die Klasse erfordert CRT-Unterstützung und Suche nach Ressourcenzeichenfolgen mithilfe des standardmäßigen MFC-Suchalgorithmus.
StrTraitMFC<wchar_t | char | TCHAR, ChTraitsOS<wchar_t | char | TCHAR>>

Die Klasse erfordert keine CRT-Unterstützung und sucht mithilfe des standardmäßigen MFC-Suchalgorithmus nach Ressourcenzeichenfolgen.

Member

Öffentliche Konstruktoren

Name	Beschreibung
`CStringT::CStringT`	Erstellt ein `CStringT` Objekt auf unterschiedliche Weise.
`CStringT::~CStringT`	Zerstört ein `CStringT` -Objekt.

Öffentliche Methoden

Name	Beschreibung
`CStringT::AllocSysString`	Ordnet eine `BSTR` Daten zu `CStringT` .
`CStringT::AnsiToOem`	Macht eine direkte Konvertierung aus dem ANSI-Zeichensatz in den OEM-Zeichensatz.
`CStringT::AppendFormat`	Fügt formatierte Daten an ein vorhandenes `CStringT` Objekt an.
`CStringT::Collate`	Vergleicht zwei Zeichenfolgen (Groß-/Kleinschreibung, verwendet gebietsschemaspezifische Informationen).
`CStringT::CollateNoCase`	Vergleicht zwei Zeichenfolgen (Groß-/Kleinschreibung wird verwendet gebietsschemaspezifische Informationen).
`CStringT::Compare`	Vergleicht zwei Zeichenfolgen (Groß-/Kleinschreibung wird beachtet).
`CStringT::CompareNoCase`	Vergleicht zwei Zeichenfolgen (Groß-/Kleinschreibung wird nicht beachtet).
`CStringT::Delete`	Löscht ein Zeichen oder 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 einer Gruppe.
`CStringT::Format`	Formatiert die Zeichenfolge wie `sprintf` dies der Fall ist.
`CStringT::FormatMessage`	Formatiert eine Nachrichtenzeichenfolge.
`CStringT::FormatMessageV`	Formatiert eine Nachrichtenzeichenfolge mithilfe einer Variablenargumentliste.
`CStringT::FormatV`	Formatiert die Zeichenfolge mithilfe einer variablen Liste 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`	Macht eine direkte Konvertierung aus dem 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 nicht in der Gruppe von Zeichen enthalten sind, die durch `pszCharSet`identifiziert werden.
`CStringT::SpanIncluding`	Extrahiert eine Teilzeichenfolge, die nur die Zeichen in einem Satz enthält.
`CStringT::Tokenize`	Extrahiert angegebene Token in einer Zielzeichenfolge.
`CStringT::Trim`	Schneidet alle führenden und nachfolgenden Leerzeichen aus der Zeichenfolge ab.
`CStringT::TrimLeft`	Schneidet führende Leerzeichen aus der Zeichenfolge ab.
`CStringT::TrimRight`	Schneidet nachfolgende Leerzeichen aus der Zeichenfolge ab.

Operatoren

Name	Beschreibung
`CStringT::operator =`	Weist einem `CStringT` Objekt einen 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 auf der linken Seite des Operators kleiner als die Zeichenfolge auf der rechten Seite ist.
`CStringT::operator >`	Bestimmt, ob die Zeichenfolge auf der linken Seite des Operators größer als die Zeichenfolge auf der rechten Seite ist.
`CStringT::operator <=`	Bestimmt, ob die Zeichenfolge auf der linken Seite des Operators kleiner oder gleich der Zeichenfolge auf der rechten Seite ist.
`CStringT::operator >=`	Bestimmt, ob die Zeichenfolge auf der linken Seite des Operators größer oder gleich der Zeichenfolge auf der rechten Seite ist.

Hinweise

CStringT erbt von CSimpleStringT "Class". Erweiterte Features, z. B. Zeichenmanipulation, Sortierung und Suche, werden von CStringT.

Hinweis

CStringT Objekte können Ausnahmen auslösen. Dies tritt auf, wenn ein CStringT Objekt aus irgendeinem Grund nicht mehr genügend Arbeitsspeicher hat.

Ein CStringT Objekt besteht aus einer Zeichenfolge mit variabler Länge. CStringT stellt Funktionen und Operatoren bereit, die der Syntax von Basic ähneln. Verkettungs- und Vergleichsoperatoren erleichtern die Verwendung von Objekten zusammen mit der vereinfachten Speicherverwaltung CStringT als normale Zeichenarrays.

Hinweis

Obwohl es möglich ist, Instanzen zu erstellen CStringT , die eingebettete NULL-Zeichen enthalten, wird 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 von und BaseType StringTraits Parametern CStringT 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. Dies geschieht, um zu verhindern, dass CStringT mehrere Male 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 ANSI-Zeichentypzeichenfolge mit CRT-Unterstützung.
`CStringW`	Eine Unicode-Zeichentypzeichenfolge 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-Zeichentypzeichenfolge ohne CRT-Unterstützung.
`CAtlStringW`	Eine Unicode-Zeichentypzeichenfolge 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 ANSI-Zeichentypzeichenfolge mit CRT-Unterstützung.
`CAtlStringW`	Eine Unicode-Zeichentypzeichenfolge 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 wird, um den unterstützten Zeichentyp ( wchar_t oder char) 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 CStringT die folgenden dokumentierten Methoden verwendet (z GetBuffer . B. oder ReleaseBuffer). Diese Methoden werden von CSimpleStringT.

Vererbungshierarchie

CSimpleStringT

CStringT

Anforderungen

Header	Verwendung
`cstringt.h`	Nur MFC-Zeichenfolgenobjekte
`atlstr.h`	Nicht-MFC-Zeichenfolgenobjekte

`CStringT::AllocSysString`

Weist eine automatisierungskompatible Zeichenfolge des Typs BSTR zu und kopiert den Inhalt des CStringT Objekts darin, einschließlich des endenden Nullzeichens.

BSTR AllocSysString() const;

Rückgabewert

Die neu zugewiesene Zeichenfolge.

Hinweise

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

Wenn diese Zeichenfolge häufig als [in] Parameter an eine COM-Funktion übergeben wird, muss der Aufrufer die Zeichenfolge freigeben. Dazu können Sie , wie im Windows SDK beschrieben, dies tun SysFreeString. Weitere Informationen finden Sie unter Zuweisung und Freigeben von Arbeitsspeicher für ein BSTR.

Weitere Informationen zu OLE-Zuordnungsfunktionen in Windows finden Sie im SysAllocString 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 sie definiert ist.

Beispiel

// OEM character 252 on most IBM-compatible computers in
// many 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 CStringT. Jedes optionale Argument (falls vorhanden) wird entsprechend der entsprechenden Formatspezifikation in pszFormat oder aus der durch nFormatIDdie Zeichenfolgenressource identifizierten 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 Generika-Text-Funktion _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.H, definiert ist, ist abhängig von dem Zeichensatz, der zur Kompilierungszeit definiert ist, entweder strcoll, wcscolloder _mbscoll, zugeordnet. Jede Funktion führt einen Vergleich zwischen Groß-/Kleinschreibung der Zeichenfolgen gemäß der aktuell verwendeten Codepage durch. Weitere Informationen finden Sie unter strcoll, , wcscoll, _strcoll_l_mbscoll, _wcscoll_l, _mbscoll_l.

`CStringT::CollateNoCase`

Vergleicht zwei Zeichenfolgen mithilfe der Generika-Text-Funktion _tcscoll.

int CollateNoCase(PCXSTR psz) const throw();

Parameter

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

Rückgabewert

Null, wenn die Zeichenfolgen identisch sind (Groß-/Kleinschreibung ignorieren), < 0, wenn dieses CStringT Objekt kleiner psz als ist (Groß-/Kleinschreibung ignorieren) oder > 0, wenn dieses CStringT Objekt größer als psz ist (Groß-/Kleinschreibung ignorieren).

Hinweise

Die generische Textfunktion _tcscoll, die in TCHAR.H, definiert ist, ist abhängig von dem Zeichensatz, der zur Kompilierungszeit definiert ist, entweder stricoll, wcsicolloder _mbsicoll, zugeordnet. Jede Funktion führt einen Vergleich zwischen Groß- und Kleinschreibung der Zeichenfolgen gemäß der derzeit verwendeten Codeseite durch. Weitere Informationen finden Sie unter strcoll, , wcscoll, _strcoll_l_mbscoll, , . _mbscoll_l_wcscoll_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.H, definiert ist, ist abhängig von dem Zeichensatz, der zur Kompilierungszeit definiert ist, entweder strcmp, wcscmpoder _mbscmp, zugeordnet. Jede Funktion führt einen Vergleich zwischen Groß- und Kleinschreibung der Zeichenfolgen durch und wird vom Gebietsschema nicht beeinflusst. Weitere Informationen finden Sie unter strcmp, wcscmp, _mbscmp.

Wenn die Zeichenfolge eingebettete NULL-Werte enthält, gilt die Zeichenfolge zum Vergleich als abgeschnitten am ersten eingebetteten Nullzeichen.

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 (Groß-/Kleinschreibung wird nicht beachtet).

int CompareNoCase(PCXSTR psz) const throw();

Parameter

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

Rückgabewert

Null, wenn die Zeichenfolgen identisch sind (Groß-/Kleinschreibung ignorieren), <0, wenn dieses CStringT Objekt kleiner psz als ist (Groß-/Kleinschreibung ignorieren) oder >0, wenn dieses CStringT Objekt größer als psz ist (Groß-/Kleinschreibung ignorieren).

Hinweise

Die generische Textfunktion_tcsicmp, die in TCHAR.Hdefiniert ist, ist abhängig von dem Zeichensatz, der zur Kompilierungszeit definiert ist, _wcsicmp entweder _stricmpzugeordnet oder_mbsicmp. Bei jeder Funktion wird ein Vergleich der Zeichenfolgen zwischen Groß- und Kleinschreibung unterschieden. Der Vergleich hängt vom LC_CTYPE Aspekt des Gebietsschemas ab, aber nicht LC_COLLATE. Weitere Informationen finden Sie unter _stricmp, , _wcsicmp, _stricmp_l_mbsicmp, , . _mbsicmp_l_wcsicmp_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 Längenzeichen nLength, nicht null-beendet.

nLength
Anzahl der Zeichen in pch.

ch
Ein einzelnes Zeichen.

pszSrc
Eine mit Null beendete Zeichenfolge, die in dieses CStringT Objekt kopiert werden soll.

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

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

varSrc
Ein Variant-Objekt, das in dieses CStringT Objekt kopiert werden 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 (sowohl für ANSI- als auch für Unicode-Zeichenzeichenfolgen).

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

SystemString
System::StringMuss sein, und das Projekt muss mit /clrkompiliert werden.

pString
Ein Handle für ein CStringT Objekt.

Hinweise

Da die Konstruktoren die Eingabedaten in neuen zugewiesenen Speicher kopieren, können Speichereinnahmen dazu führen. Einige dieser Konstruktoren dienen als Konvertierungsfunktionen. Auf diese Weise können Sie beispielsweise ein LPTSTR Objekt ersetzen, bei dem ein CStringT Objekt erwartet wird.

CStringT( LPCSTR lpsz ): Erstellt ein Unicode CStringT aus einer ANSI-Zeichenfolge. Sie können diesen Konstruktor auch verwenden, um eine Zeichenfolgenressource zu laden, wie im folgenden Beispiel gezeigt.
CStringT(LPCWSTR lpsz ): Erstellt eine CStringT aus einer Unicode-Zeichenfolge.
CStringT( const unsigned char* psz ): Ermöglicht das Konstruieren eines CStringT Zeigers auf unsigned char.

Hinweis

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

Der strSrc Parameter kann entweder ein Objekt oder CThisSimpleString ein CStringT Objekt sein. Verwenden Sie für CStringT, eine seiner Standardinstanziationen (CString, CStringAoder CStringW); für , verwenden CThisSimpleStringSie einen this Zeiger. CThisSimpleStringdeklariert eine Instanz der Klasse, bei der CSimpleStringT es sich um eine kleinere Zeichenfolgenklasse mit weniger integrierter Funktionalität als der CStringT Klasse handelt.

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

Hinweis

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 Zeichen oder 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.

Hinweise

Wenn nCount die Zeichenfolge länger 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`

Sucht 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 Teilzeichenfolge, nach der gesucht werden soll.

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

Hinweise

Die Funktion wird überladen, um sowohl einzelne Zeichen (ähnlich der Laufzeitfunktion) als auch Zeichenfolgen (ähnlich wie strstrdie Laufzeitfunktionstrchr) zu 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-Zeichen pszCharSetentspricht.

int FindOneOf(PCXSTR pszCharSet) const throw();

Parameter

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

Rückgabewert

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

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 CStringT auf die gleiche Weise sprintf_s wie Daten in ein Zeichenarray im C-Format.

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

Parameter

nFormatID
Der Zeichenfolgenressourcenbezeichner, der die Formatsteuerelementzeichenfolge enthält.

pszFormat
Eine Formatsteuerelementzeichenfolge.

argument
Optionale Argumente.

Hinweise

Diese Funktion formatiert und speichert eine Reihe von Zeichen und Werten in der CStringT. Jedes optionale Argument (falls vorhanden) wird entsprechend der entsprechenden Formatspezifikation in pszFormat oder aus der durch nFormatIDdie Zeichenfolgenressource identifizierten Zeichenfolgenressource konvertiert und ausgegeben.

Der Aufruf schlägt fehl, wenn das Zeichenfolgenobjekt selbst als Parameter Formatangeboten 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: 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 Nachrichtenzeichenfolge.

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

Parameter

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

pszFormat
Verweist auf die Formatsteuerelementzeichenfolge. Es wird nach Einfügungen gescannt und entsprechend formatiert. Die Formatzeichenfolge ähnelt den Formatzeichenfolgen im Format der Laufzeitfunktion printf-Formatzeichenfolgen, mit der Ausnahme, dass die Parameter in eine beliebige Reihenfolge eingefügt werden können.

argument
Optionale Argumente.

Hinweise

Für die Funktion ist eine Nachrichtendefinition als Eingabe erforderlich. Die Nachrichtendefinition wird durch pszFormat oder von der Zeichenfolgenressource bestimmt, die durch nFormatID. Die Funktion kopiert den formatierten Nachrichtentext in das CStringT Objekt und verarbeitet bei Bedarf alle eingebetteten Einfügesequenzen.

Hinweis

FormatMessage versucht, den Systemspeicher für die neu formatierte Zeichenfolge zuzuweisen. Wenn dieser Versuch fehlschlägt, wird automatisch eine Speicher ausnahme ausgelöst.

Jedes Einfügen muss über einen entsprechenden Parameter verfügen, der dem pszFormat Parameter folgt nFormatID . 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
Verweist auf die Formatsteuerelementzeichenfolge. Es wird nach Einfügungen gescannt und entsprechend formatiert. Die Formatzeichenfolge ähnelt den Formatzeichenfolgen im Format der Laufzeitfunktion printf-Formatzeichenfolgen, mit der Ausnahme, dass die Parameter in eine beliebige Reihenfolge eingefügt werden können.

pArgList
Zeigen Sie auf eine Liste von Argumenten.

Hinweise

Für die Funktion ist eine Nachrichtendefinition als Eingabe erforderlich, die von pszFormat. Die Funktion kopiert den formatierten Nachrichtentext und eine variable Liste von Argumenten in das CStringT Objekt, wobei bei Bedarf alle eingebetteten Einfügesequenzen verarbeitet werden.

Hinweis

FormatMessageV ruft auf CStringT::FormatMessage, wodurch versucht wird, den Systemspeicher für die neu formatierte Zeichenfolge zuzuweisen. Wenn dieser Versuch fehlschlägt, wird automatisch eine Speicher ausnahme 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
Verweist auf die Formatsteuerelementzeichenfolge. Es wird nach Einfügungen gescannt und entsprechend formatiert. Die Formatzeichenfolge ähnelt den Formatzeichenfolgen im Format der Laufzeitfunktion printf-Formatzeichenfolgen, mit der Ausnahme, dass die Parameter in eine beliebige Reihenfolge eingefügt werden können.

args
Zeigen Sie auf eine Liste von Argumenten.

Hinweise

Schreibt eine formatierte Zeichenfolge und eine variable Liste von Argumenten auf die gleiche Weise in eine CStringT Zeichenfolge, wie vsprintf_s Daten in ein C-Zeichenarray formatiert werden.

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 mit Null beendete 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 befindet sich in Form einer mit Null beendeten 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 stattfindet.

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 gibt das erste Zeichen an, das verschoben wird, um Platz für das Zeichen oder die Teilzeichenfolge zu schaffen. Wenn nIndex null ist, tritt die Einfügung vor der gesamten Zeichenfolge auf. Wenn nIndex höher als die Länge der Zeichenfolge ist, verkettet die Funktion die vorhandene Zeichenfolge und das neue Material, das entweder ch oder psz.

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 äußerst nCount linken 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 überschritten wird, wird die gesamte Zeichenfolge extrahiert. Left ähnelt der Left-Funktion von ///Visual Basic.

Bei Multibyte-Zeichensätzen (MBCS) nCount wird jede 8-Bit-Sequenz als Zeichen behandelt, sodass nCount die Anzahl von Multibytezeichen multipliziert mit zwei Zeichen 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 nID identifiziert wird, 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

Nonzero, wenn die Ressourcenlast erfolgreich war; andernfalls 0.

Hinweise

Lädt die Zeichenfolgenressource (nID) aus dem angegebenen Modul (hInstance) mithilfe 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 kleingeschriebene Zeichenfolge.

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`

Umkehrt die Reihenfolge der Zeichen im CStringT Objekt.

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 großgeschriebene Zeichenfolge.

CStringT& MakeUpper();

Rückgabewert

Die resultierende Zeichenfolge in Großbuchstaben.

Hinweise

Beispiel

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

CAtlString s(_T("abc"));

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

`CStringT::Mid`

Extrahiert eine Teilzeichenfolge mit 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 Funktion "Basismittel" (mit der Ausnahme, dass Indizes in "Einfach" einsbasiert sind).

Bei Multibyte-Zeichensätzen (MBCS) nCount wird auf jedes 8-Bit-Zeichen verwiesen. Das heißt, ein Lead- und Trail-Byte in einem Multibyte-Zeichen 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 sie definiert ist.

Beispiel

Ein Beispiel hierfür finden Sie unter 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
A CStringT , das dieser Zeichenfolge zugewiesen werden soll.

str
Ein Verweis auf ein CThisSimpleString-Objekt.

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

BaseType
Der Basistyp der Zeichenfolge.

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 Zuordnungsoperator akzeptiert ein anderes CStringT Objekt, einen Zeichenzeiger oder ein einzelnes Zeichen. Speicher exceptions can occur whenever you use this operator because new storage can be allocated.

Weitere Informationen CThisSimpleStringfinden Sie im Abschnitt "Hinweise" von CStringT::CStringT.

Hinweis

`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
A CStringT , das mit einer Zeichenfolge oder einem Zeichen verkettet werden soll.

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

psz1
Ein Zeiger auf eine mit 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 CStringT Objekt und eine mit 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

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 an das 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 angibt, ob das Projekt eine MFC-DLL ist oder nicht.

BaseType
Der Basistyp der Zeichenfolge.

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
A CStringT , das mit dieser Zeichenfolge verkettet werden soll.

Hinweise

Der Operator akzeptiert ein anderes CStringT Objekt, einen Zeichenzeiger oder ein einzelnes Zeichen. Speicher exceptions can occur whenever you use this concatenation operator because new storage can be allocated for characters added to this CStringT object.

Weitere Informationen CThisSimpleStringfinden Sie im Abschnitt "Hinweise" von CStringT::CStringT.

Hinweis

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

str2
A CStringT zum Vergleich.

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

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

Hinweise

Überprüft, ob eine Zeichenfolge oder ein Zeichen auf der linken Seite gleich einer Zeichenfolge oder einem Zeichen auf der rechten Seite ist und zurückgegeben oder FALSE entsprechend.TRUE

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

str2
A CStringT zum Vergleich.

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

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

Hinweise

Überprüft, ob eine Zeichenfolge oder ein Zeichen auf der linken Seite nicht mit einer Zeichenfolge oder einem Zeichen auf der rechten Seite identisch 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 auf der linken Seite des Operators 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
A CStringT zum Vergleich.

str2
A CStringT zum Vergleich.

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

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

Hinweise

Lexikographischer Vergleich zwischen Zeichenfolgen, Zeichen nach 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 auf der linken Seite des Operators 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
A CStringT zum Vergleich.

str2
A CStringT zum Vergleich.

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

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

Hinweise

Lexikographischer Vergleich zwischen Zeichenfolgen, Zeichen nach 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 auf der linken Seite des Operators kleiner oder gleich der 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
A CStringT zum Vergleich.

str2
A CStringT zum Vergleich.

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

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

Hinweise

Lexikographischer Vergleich zwischen Zeichenfolgen, Zeichen nach 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 auf der linken Seite des Operators größer oder gleich der 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
A CStringT zum Vergleich.

str2
A CStringT zum Vergleich.

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

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

Hinweise

Lexikographischer Vergleich zwischen Zeichenfolgen, Zeichen nach 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 Zeichen, die aus der Zeichenfolge entfernt wurden. Null, wenn die Zeichenfolge nicht geändert wird.

Hinweise

Bei Vergleichen für das Zeichen wird zwischen Groß- und Kleinschreibung unterschieden.

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 mithilfe einer anderen Teilzeichenfolge. Beide Teilzeichenfolgen werden null beendet. In der zweiten Version wird eine oder mehrere Kopien eines Zeichens durch ein anderes Zeichen ersetzt. Beide Versionen arbeiten mit den zeichendaten, die in CStringT.

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

Parameter

pszOld
Ein Zeiger auf eine mit Null beendete Zeichenfolge, die durch pszNewersetzt werden soll.

pszNew
Ein Zeiger auf eine mit Null beendete Zeichenfolge, die ersetzt pszOldwird.

chOld
Das Zeichen, durch chNewdas ersetzt werden soll.

chNew
Das Zeichen, das ersetzt wird chOld.

Rückgabewert

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

Hinweise

Replace kann die Länge der Zeichenfolge ändern, da pszNew sie pszOld nicht die gleiche Länge aufweisen muss, und mehrere Kopien der alten Teilzeichenfolge können in die neue geändert werden. Bei der Funktion wird eine Übereinstimmung zwischen Groß- und Kleinschreibung beachtet.

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

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

For CString, the character data type is selected at compile time, based on whether the constants in the following table are defined.

Definierte Konstante	Zeichendatentyp
`_UNICODE`	Breitzeichen
`_MBCS`	Multibytezeichen
Neither	Einzelne Bytezeichen
Beides	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`

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

int ReverseFind(XCHAR ch) const throw();

Parameter

ch
Das zeichen, nach dem gesucht werden soll.

Rückgabewert

Der nullbasierte Index des letzten Zeichens in diesem CStringT Objekt, das dem angeforderten Zeichen entspricht, 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 Zeichen (d. h. ganz rechts) nCount 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 überschritten wird, wird die gesamte Zeichenfolge extrahiert. Right ist vergleichbar mit der Basic-Funktion Right (außer dass Indizes in Basic nullbasiert sind).

Bei Multibyte-Zeichensätzen (MBCS) nCount wird auf jedes 8-Bit-Zeichen verwiesen, d. h. ein Lead- und Trailbyte-Byte in einem Multibyte-Zeichen 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`

Verteilt die BSTR verweisenden pbstr Elemente durch und kopiert den Inhalt des CStringT Objekts in das Objekt, einschließlich des NULL Zeichens.

BSTR SetSysString(BSTR* pbstr) const;

Parameter

pbstr
Ein Zeiger auf eine Zeichenfolge.

Rückgabewert

Die neue Zeichenfolge.

Hinweise

Je nach Inhalt des CStringT Objekts kann sich der Wert des BSTR Verweises pbstr ändern. Die Funktion löst ein CMemoryException , wenn nicht genügend Arbeitsspeicher vorhanden ist.

Diese Funktion wird normalerweise verwendet, um den Wert von Zeichenfolgen zu ändern, die per Verweis für die Automatisierung ü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 nicht in der Gruppe von Zeichen enthalten sind, die durch pszCharSetidentifiziert werden.

CStringT SpanExcluding(PCXSTR pszCharSet) const;

Parameter

pszCharSet
Eine Zeichenfolge, die als Satz von Zeichen interpretiert wird.

Rückgabewert

Eine Teilzeichenfolge, die Zeichen in der Zeichenfolge enthält, die nicht pszCharSetenthalten sind, beginnend mit dem ersten Zeichen in der Zeichenfolge und endet mit dem ersten Zeichen in der Zeichenfolge, das ebenfalls in pszCharSet der Zeichenfolge enthalten ist (d. h., 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 pszCharSet in der Zeichenfolge gefunden wird.

Hinweise

SpanExcluding extrahiert und gibt alle Zeichen zurück, die dem ersten Vorkommen eines Zeichens pszCharSet vorausgehen (mit anderen Worten, das Zeichen aus pszCharSet und alle Zeichen, die darauf in der Zeichenfolge folgen, werden nicht zurückgegeben). Wenn in der Zeichenfolge kein Zeichen pszCharSet 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 der Gruppe von Zeichen befinden, die durch pszCharSet.

CStringT SpanIncluding(PCXSTR pszCharSet) const;

Parameter

pszCharSet
Eine Zeichenfolge, die als Satz von Zeichen interpretiert wird.

Rückgabewert

Eine Teilzeichenfolge, die Zeichen in der Zeichenfolge enthält, die pszCharSetmit dem ersten Zeichen in der Zeichenfolge beginnen und enden, wenn ein Zeichen in der Zeichenfolge gefunden wird, die sich nicht in pszCharSetder Zeichenfolge befindet. SpanIncluding gibt eine leere Teilzeichenfolge zurück, wenn das erste Zeichen in der Zeichenfolge nicht im angegebenen Satz enthalten ist.

Hinweise

Wenn das erste Zeichen der Zeichenfolge nicht im Zeichensatz enthalten ist, wird SpanIncluding eine leere Zeichenfolge zurückgegeben. Andernfalls wird eine Sequenz aufeinander folgender Zeichen zurückgegeben, die sich im Satz 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 mit Tokentrennzeichen. Die Reihenfolge dieser Trennzeichen ist nicht wichtig.

iStart
Der nullbasierte Index, um die Suche zu beginnen.

Rückgabewert

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

Hinweise

Die Tokenize Funktion findet das nächste Token in der Zielzeichenfolge. Der Satz von Zeichen in pszTokens gibt mögliche Trennzeichen des zu findenden Tokens an. Bei jedem Aufruf der Tokenize Funktion beginnt bei iStart, überspringt führende Trennzeichen und gibt ein CStringT Objekt zurück, das das aktuelle Token enthält. Dabei handelt es sich um die Zeichenfolge von Zeichen bis zum nächsten Trennzeichen. Der Wert von iStart wird aktualisiert, um die Position nach dem endenden Trennzeichen oder -1 zu sein, wenn das Ende der Zeichenfolge erreicht wurde. Weitere Token können aus dem rest der Zielzeichenfolge durch eine Reihe von Aufrufen Tokenizeaufgeschlüsselt werden. Dabei iStart können Sie nachverfolgen, wo in der Zeichenfolge das nächste Token gelesen werden soll. Wenn keine weiteren Token vorhanden sind, gibt die Funktion eine leere Zeichenfolge zurück und iStart wird auf -1 festgelegt.

Im Gegensatz zu den CRT-Tokenisierungsfunktionen wie strtok_s, _strtok_s_l, wcstok_s, _wcstok_s_l, _mbstok_s, wird _mbstok_s_lTokenize 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 aus diesem Beispiel lautet wie folgt:

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

`CStringT::Trim`

Schneidet führende und nachfolgende Zeichen aus der Zeichenfolge ab.

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 nachgestellten Vorkommen von Zeichen in pszTargets werden vom CStringT Objekt gekürzt.

Rückgabewert

Gibt die gekürzte Zeichenfolge zurück.

Hinweise

Entfernt alle führenden und nachgestellten Vorkommen eines der folgenden Elemente:

Das von chTarget.
Alle Zeichen in der durch 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 aus diesem Beispiel lautet wie folgt:

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

`CStringT::TrimLeft`

Schneidet führende Zeichen aus der Zeichenfolge ab.

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 vom CStringT Objekt gekürzt.

Rückgabewert

Die resultierende gekürzte Zeichenfolge.

Hinweise

Entfernt alle führenden und nachgestellten Vorkommen eines der folgenden Elemente:

Das von chTarget.
Alle Zeichen in der durch 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`

Schneidet nachfolgende Zeichen aus der Zeichenfolge ab.

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 nachfolgenden Vorkommen von Zeichen in pszTargets werden vom CStringT Objekt gekürzt.

Rückgabewert

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

Hinweise

Entfernt nachfolgende Vorkommen eines der folgenden Elemente:

Das von chTarget.
Alle Zeichen in der durch pszTargets.
Leerzeichen.

Die CStringT& TrimRight(XCHAR chTarget) Version akzeptiert einen Zeichenparameter und entfernt alle Kopien dieses Zeichens aus dem Ende der CStringT Zeichenfolgendaten. Sie beginnt am Ende der Zeichenfolge und arbeitet an der Vorderseite. Es wird angehalten, wenn ein anderes Zeichen gefunden wird oder wenn CStringT keine Zeichendaten mehr vorhanden sind.

Die CStringT& TrimRight(PCXSTR pszTargets) Version akzeptiert eine mit Null beendete Zeichenfolge, die alle verschiedenen Zeichen enthält, nach denen gesucht werden soll. Es entfernt alle Kopien dieser Zeichen im CStringT Objekt. Sie beginnt am Ende der Zeichenfolge und arbeitet an der Vorderseite. Es wird angehalten, wenn ein Zeichen gefunden wird, das sich nicht in der Zielzeichenfolge befindet, oder wenn CStringT keine Zeichendaten mehr vorhanden sind. Es wird nicht versucht, die gesamte Zielzeichenfolge mit einer Teilzeichenfolge am Ende von CStringT.

Für die CStringT& TrimRight() Version sind keine Parameter erforderlich. Sie schneidet alle nachfolgenden Leerzeichen am Ende der CStringT Zeichenfolge ab. Leerzeichen können Zeilenumbrüche, Leerzeichen oder Tabstopps 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
ATL/MFC Shared Classes
CSimpleStringT Klasse

Freigeben über

CStringT-Klasse

Syntax

Parameter

Member

Öffentliche Konstruktoren

Öffentliche Methoden

Operatoren

Hinweise

Vordefinierte CStringT-Typen

Vererbungshierarchie

Anforderungen

CStringT::AllocSysString

Rückgabewert

Hinweise

Beispiel

CStringT::AnsiToOem

Hinweise

Beispiel

CStringT::AppendFormat

Parameter

Hinweise

Beispiel

CStringT::Collate

Parameter

Rückgabewert

Hinweise

CStringT::CollateNoCase

Parameter

Rückgabewert

Hinweise

Beispiel

CStringT::Compare

Parameter

Rückgabewert

Hinweise

Beispiel

CStringT::CompareNoCase

Parameter

Rückgabewert

Hinweise

Beispiel

CStringT::CStringT

Parameter

Hinweise

Beispiel

CStringT::~CStringT

Hinweise

CStringT::Delete

Parameter

Rückgabewert

Hinweise

Beispiel

CStringT::Find

Parameter

Rückgabewert

Hinweise

Beispiel

CStringT::FindOneOf

Parameter

Rückgabewert

Hinweise

Beispiel

CStringT::Format

Parameter

Hinweise

Beispiel

CStringT::FormatMessage

Parameter

Hinweise

Beispiel

CStringT::FormatMessageV

Parameter

Hinweise

CStringT::FormatV

Parameter

Hinweise

Beispiel

CStringT::GetEnvironmentVariable

Parameter

`CStringT`-Klasse

`CStringT::AllocSysString`

`CStringT::AnsiToOem`

`CStringT::AppendFormat`

`CStringT::Collate`

`CStringT::CollateNoCase`

`CStringT::Compare`

`CStringT::CompareNoCase`

`CStringT::CStringT`

`CStringT::~CStringT`

`CStringT::Delete`

`CStringT::Find`

`CStringT::FindOneOf`

`CStringT::Format`

`CStringT::FormatMessage`

`CStringT::FormatMessageV`

`CStringT::FormatV`

`CStringT::GetEnvironmentVariable`

`CStringT::Insert`

`CStringT::Left`

`CStringT::LoadString`

`CStringT::MakeLower`

`CStringT::MakeReverse`

`CStringT::MakeUpper`

`CStringT::Mid`

`CStringT::OemToAnsi`

`CStringT::operator =`

`CStringT::operator +`

`CStringT::operator +=`

`CStringT::operator ==`

`CStringT::operator !=`

`CStringT::operator <`

`CStringT::operator >`

`CStringT::operator <=`

`CStringT::operator >=`