CStringT osztály

Ez az osztály egy objektumot CStringT jelöl.

Szemantika

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

Paraméterek

BaseType
A sztringosztály karaktertípusa. A következők egyike lehet:

• char (ANSI-karaktersztringek esetén).

• wchar_t (Unicode-karaktersztringek esetén).

• TCHAR (ANSI- és Unicode-karaktersztringekhez egyaránt).

StringTraits
Meghatározza, hogy a sztringosztálynak szüksége van-e c Run-Time (CRT) kódtárra, és hol találhatók a sztringerőforrások. A következők egyike lehet:

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

  Az osztályhoz CRT-támogatás szükséges, és erőforrás-sztringeket keres a megadott m_hInstResource modulban (az alkalmazás modulosztályának egy tagja).

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

  Az osztály nem igényel CRT-támogatást, és nem keres erőforrás-sztringeket a megadott m_hInstResource modulban (az alkalmazás modulosztályának tagja).

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

  Az osztályhoz CRT-támogatás szükséges, és a standard MFC keresési algoritmus használatával keres erőforrás-sztringeket.

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

  Az osztály nem igényel CRT-támogatást, és nem keres erőforrás-sztringeket a szabványos MFC keresési algoritmus használatával.

Tagok

Nyilvános konstruktorok

Név	Leírás
CStringT::CStringT	Különböző módokon hoz létre objektumokat CStringT .
CStringT::~CStringT	Elpusztít egy objektumot CStringT .

Nyilvános metódusok

Név	Leírás
CStringT::AllocSysString	BSTR CStringT Adatokat foglal le.
CStringT::AnsiToOem	Helyszíni átalakítást végez az ANSI-karakterkészletről az OEM-karakterkészletre.
CStringT::AppendFormat	Formázott adatok hozzáfűzése egy meglévő CStringT objektumhoz.
CStringT::Collate	Két sztringet hasonlít össze (a kis- és nagybetűk megkülönböztetése területi adatokat használ).
CStringT::CollateNoCase	Két sztringet hasonlít össze (a kis- és nagybetűk nem érzékenyek, területi specifikus információkat használnak).
CStringT::Compare	Két sztringet hasonlít össze (kis- és nagybetűk megkülönböztetése).
CStringT::CompareNoCase	Két sztringet hasonlít össze (a kis- és nagybetűk nem érzékenyek).
CStringT::Delete	Karaktert vagy karaktert töröl egy sztringből.
CStringT::Find	Megkeres egy karaktert vagy egy nagyobb sztringben lévő részsztringet.
CStringT::FindOneOf	Megkeresi az első egyező karaktert egy készletből.
CStringT::Format	Formázza a sztringet a következőképpen sprintf .
CStringT::FormatMessage	Üzenetsztring formázása.
CStringT::FormatMessageV	Üzenetsztring formázása változó argumentumlistával.
CStringT::FormatV	Formázza a sztringet az argumentumok változólistájának használatával.
CStringT::GetEnvironmentVariable	A sztringet a megadott környezeti változó értékére állítja.
CStringT::Insert	Egyetlen karaktert vagy alsztringet szúr be az adott indexbe a sztringen belül.
CStringT::Left	Kinyeri egy sztring bal oldali részét.
CStringT::LoadString	Betölt egy meglévő CStringT objektumot egy Windows-erőforrásból.
CStringT::MakeLower	A sztringben szereplő összes karaktert kisbetűs karakterekké alakítja.
CStringT::MakeReverse	Megfordítja a sztringet.
CStringT::MakeUpper	A sztring összes karakterét nagybetűssé alakítja.
CStringT::Mid	Kinyeri egy sztring középső részét.
CStringT::OemToAnsi	Helyben történő átalakítást végez az OEM-karakterkészletről az ANSI-karakterkészletre.
CStringT::Remove	Eltávolítja a megadott karaktereket egy sztringből.
CStringT::Replace	A megjelölt karaktereket más karakterekre cseréli.
CStringT::ReverseFind	Megkeres egy karaktert egy nagyobb sztringben; a végétől kezdődik.
CStringT::Right	Kinyeri a sztring megfelelő részét.
CStringT::SetSysString	BSTR Meglévő objektumot állít be egy CStringT objektumból származó adatokkal.
CStringT::SpanExcluding	Kinyeri a sztringből az első karakterrel kezdődő karaktereket, amelyek nem szerepelnek a megadott karakterkészletben pszCharSet.
CStringT::SpanIncluding	Kinyer egy olyan részsztringet, amely csak a halmazban lévő karaktereket tartalmazza.
CStringT::Tokenize	Kinyeri a megadott jogkivonatokat egy célsztringben.
CStringT::Trim	Levágja az összes kezdő és záró szóköz karaktert a sztringből.
CStringT::TrimLeft	Levágja a kezdő szóköz karaktereit a sztringből.
CStringT::TrimRight	Levágja a sztring záró szóköz karaktereit.

Működtetők

Név	Leírás
CStringT::operator =	Új értéket rendel egy CStringT objektumhoz.
CStringT::operator +	Összefűz két sztringet, vagy egy karaktert és egy sztringet.
CStringT::operator +=	Egy meglévő sztring végéhez fűz egy új sztringet.
CStringT::operator ==	Meghatározza, hogy két sztring logikailag egyenlő-e.
CStringT::operator !=	Meghatározza, hogy két sztring logikailag nem egyenlő-e.
CStringT::operator <	Meghatározza, hogy az operátor bal oldalán lévő sztring kisebb-e, mint a jobb oldalon lévő sztring.
CStringT::operator >	Meghatározza, hogy az operátor bal oldalán lévő sztring nagyobb-e, mint a jobb oldalon lévő sztring.
CStringT::operator <=	Meghatározza, hogy az operátor bal oldalán lévő sztring kisebb vagy egyenlő-e a jobb oldalon lévő sztringgel.
CStringT::operator >=	Meghatározza, hogy az operátor bal oldalán lévő sztring nagyobb vagy egyenlő-e a jobb oldalon lévő sztringnél.

Megjegyzések

CStringTaz osztálytólCSimpleStringT örökli. A speciális funkciókat, például a karakterkezelést, a rendezést és a keresést a program implementálja CStringT.

Megjegyzés:

CStringT objektumok képesek kivételeket kivenni. Ez akkor fordul elő, ha egy CStringT objektum bármilyen okból elfogy a memóriából.

Az CStringT objektumok változó hosszúságú karaktersorozatból állnak. CStringT az Alapszintűhöz hasonló szintaxist használó függvényeket és operátorokat biztosít. Az összefűzési és összehasonlító operátorok az egyszerűsített memóriakezeléssel együtt megkönnyítik az objektumok használatát, CStringT mint a hagyományos karaktertömbök.

Megjegyzés:

Bár beágyazott null karaktereket tartalmazó példányok hozhatók létre CStringT , javasoljuk, hogy ellenük. A beágyazott null karaktereket tartalmazó objektumok metódusainak CStringT és operátorainak meghívása nem kívánt eredményeket eredményezhet.

A paraméterek és BaseType a paraméterek StringTraits különböző kombinációinak használatával az CStringT objektumok a következő típusok lehetnek, amelyeket az ATL-kódtárak előre definiáltak.

Ha ATL-alkalmazásban használja:

CString, CStringAés CStringW az MFC DLL-ből (MFC90.DLL) exportálják, soha nem felhasználói DLL-ekből. Ez azért van így, hogy ne CStringT legyen többször definiálva.

Megjegyzés:

Ha a kód tartalmazza a sztringosztályok CStringT használatával történő exportálása során leírt linkerhibák kerülő megoldását, távolítsa el a kódot. Már nincs rá szükség.

Az MFC-alapú alkalmazásokban a következő sztringtípusok érhetők el:

CStringT-típus	Nyilatkozat
CStringA	ANSI-karaktertípus-sztring CRT-támogatással.
CStringW	Unicode karaktertípusú sztring CRT-támogatással.
CString	ANSI- és Unicode-karaktertípusok is CRT-támogatással.

A definiált projektekben ATL_CSTRING_NO_CRT a következő sztringtípusok érhetők el:

CStringT-típus	Nyilatkozat
CAtlStringA	ANSI-karakter típusú sztring CRT-támogatás nélkül.
CAtlStringW	Unicode karaktertípusú sztring CRT-támogatás nélkül.
CAtlString	AZ ANSI- és Unicode-karaktertípusok is CRT-támogatás nélkül.

A következő sztringtípusok érhetők el olyan projektekben, ahol ATL_CSTRING_NO_CRT nincs definiálva:

CStringT-típus	Nyilatkozat
CAtlStringA	ANSI-karaktertípus-sztring CRT-támogatással.
CAtlStringW	Unicode karaktertípusú sztring CRT-támogatással.
CAtlString	ANSI- és Unicode-karaktertípusok is CRT-támogatással.

CString az objektumok a következő jellemzőkkel is rendelkeznek:

• CStringT az összefűzési műveletek miatt az objektumok növekedhetnek.

• CStringT az objektumok az "érték szemantikát" követik. Az objektumok tényleges sztringként CStringT , nem pedig sztringre mutató mutatóként tekinthetők.

• A függvényargumentumok objektumait CStringT szabadon helyettesíthetiPCXSTR.

• Sztringpufferek egyéni memóriakezelése. További információ: Memóriakezelés és CStringT.

CStringT előre definiált típusok

Mivel CStringT egy sablonargumentumot használ a támogatott karaktertípus wchar_tchar definiálásához, a metódusparaméter-típusok időnként bonyolultak lehetnek. A probléma egyszerűsítése érdekében előre definiált típusok halmaza van definiálva, és az CStringT egész osztályban használható. Az alábbi táblázat a különböző típusokat sorolja fel:

Név	Leírás
XCHAR	Egyetlen karakter (vagy wchar_tchar) ugyanazzal a karaktertípussal, mint az CStringT objektum.
YCHAR	Egyetlen karakter (vagy wchar_tchar) objektumként CStringT az ellenkező karaktertípussal.
PXSTR	Mutató egy olyan karaktersztringre (vagy wchar_tchar) , amelynek karaktertípusa megegyezik az CStringT objektummal.
PYSTR	Mutató egy karaktersztringre (vagy wchar_tchar) az ellenkező karaktertípussal, mint objektum CStringT .
PCXSTR	Mutató egy olyan karaktersztringre const (vagy wchar_tchar) , amelynek karaktertípusa megegyezik az CStringT objektummal.
PCYSTR	Mutató egy karaktersztringre const (vagy wchar_tchar ) az ellenkező karaktertípussal, mint objektumCStringT.

Megjegyzés:

A korábban nem dokumentált metódusokat CString (például AssignCopy) használó kódot olyan kódra kell cserélni, amely a következő dokumentált módszereket CStringT használja (például GetBuffer vagy ReleaseBuffer). Ezek a metódusok a következőtől CSimpleStringTöröklődnek:

Öröklési hierarchia

CSimpleStringT

CStringT

Követelmények

Fejléc	Használat a következőhöz:
cstringt.h	Csak MFC-sztringobjektumok
atlstr.h	Nem MFC-sztringobjektumok

CStringT::AllocSysString

Egy Automation-kompatibilis sztringet foglal le a típusból BSTR , és bemásolja az CStringT objektum tartalmát, beleértve a befejező null karaktert is.

BSTR AllocSysString() const;

Visszaadott érték

Az újonnan lefoglalt sztring.

Megjegyzések

Az MFC-programokban a program osztálytCMemoryException ad, ha nincs elegendő memória. Az ATL-programokban egy CAtlException van dobva. Ezt a függvényt általában az Automation sztringjeinek visszaadására használják.

Ha ezt a sztringet paraméterként [in] adja át egy COM-függvénynek, akkor a hívónak meg kell szabadítnia a sztringet. Ez a Windows SDK-ban leírt módon SysFreeStringvégezhető el. További információ: Memória kiosztása és felszabadítása .BSTR

A Windows OLE foglalási függvényeivel kapcsolatos további információkért lásd SysAllocString a Windows SDK-t.

példa

Az alábbi példa bemutatja a CStringT::AllocSysString használatát.

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

Az objektum összes karakterét CStringT átalakítja az ANSI-karakterkészletből az OEM karakterkészletbe.

void AnsiToOem();

Megjegyzések

A függvény nem érhető el, ha _UNICODE definiálva van.

példa

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

Formázott adatok hozzáfűzése egy meglévő CStringT objektumhoz.

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

Paraméterek

pszFormat
Formátumvezérlő sztring.

nFormatID
A formátumvezérlő sztringet tartalmazó sztringerőforrás-azonosító.

argument
Nem kötelező argumentumok.

Megjegyzések

Ez a függvény formáz és fűz hozzá egy sor karaktert és értéket a CStringT. Az egyes választható argumentumok (ha vannak ilyenek) a megfelelő formátumspecifikációnak megfelelően lesznek konvertálva és hozzáfűzve az általuk azonosított sztringerőforrásban pszFormatnFormatIDvagy -forrásból.

példa

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

Két sztringet hasonlít össze az általános szöveg függvénnyel _tcscoll.

int Collate(PCXSTR psz) const throw();

Paraméterek

psz
Az összehasonlításhoz használt másik sztring.

Visszaadott érték

Nulla, ha a sztringek azonosak, 0, ha ez < az objektum kisebb, mint CStringT, vagy psz 0, ha ez az > objektum nagyobb, mint CStringT. psz

Megjegyzések

A fordításkor definiált karakterkészlettől függően a generic-text függvény _tcscolla fordítási időpontban TCHAR.Hstrcollwcscoll_mbscolldefiniált karakterkészlethez igazodik. Minden függvény a jelenleg használt kódlapnak megfelelően kis- és nagybetűkre érzékenyen hasonlítja össze a sztringeket. További információ: strcoll, wcscoll, _mbscoll, _strcoll_l, _wcscoll_l_mbscoll_l.

CStringT::CollateNoCase

Két sztringet hasonlít össze az általános szöveg függvénnyel _tcscoll.

int CollateNoCase(PCXSTR psz) const throw();

Paraméterek

psz
Az összehasonlításhoz használt másik sztring.

Visszaadott érték

Nulla, ha a sztringek azonosak (a kis- és nagybetűket figyelmen kívül hagyva), < 0, ha ez az CStringT objektum kisebb, mint psz (a kis- és nagybetűket figyelmen kívül hagyva), vagy 0, ha ez az > objektum nagyobb, mint CStringT (a kis- és psz nagybetűket figyelmen kívül hagyva).

Megjegyzések

A fordításkor definiált karakterkészlettől függően a generic-text függvény _tcscolla fordítási időpontban TCHAR.Hstricollwcsicoll_mbsicolldefiniált karakterkészlethez igazodik. Minden függvény a jelenleg használt kódlapnak megfelelően kis- és nagybetűs összehasonlítást végez a sztringek között. További információ: strcoll, wcscoll, _mbscoll, _strcoll_l, _wcscoll_l. _mbscoll_l

példa

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

Két sztringet hasonlít össze (kis- és nagybetűk megkülönböztetése).

int Compare(PCXSTR psz) const;

Paraméterek

psz
Az összehasonlításhoz használt másik sztring.

Visszaadott érték

Nulla, ha a sztringek azonosak, 0, ha ez < az objektum kisebb, mint CStringT, vagy psz 0, ha ez az > objektum nagyobb, mint CStringT. psz

Megjegyzések

A fordításkor definiált karakterkészlettől függően a generic-text függvény _tcscmpa fordítási időpontban TCHAR.Hstrcmpwcscmp_mbscmpdefiniált karakterkészlethez igazodik. Minden függvény megkülönbözteti a sztringek kis- és nagybetűket, és a területi beállítások nem befolyásolják. További információ: strcmp, wcscmp. _mbscmp

Ha a sztring beágyazott null értékeket tartalmaz, összehasonlítás céljából a sztring az első beágyazott null karakternél csonkoltnak minősül.

példa

Az alábbi példa bemutatja a CStringT::Compare használatát.

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

Két sztringet hasonlít össze (a kis- és nagybetűk nem érzékenyek).

int CompareNoCase(PCXSTR psz) const throw();

Paraméterek

psz
Az összehasonlításhoz használt másik sztring.

Visszaadott érték

Nulla, ha a sztringek azonosak (a kis- és nagybetűket figyelmen kívül hagyva), <0, ha ez az CStringT objektum kisebb, mint psz (a kis- és nagybetűket figyelmen kívül hagyva), vagy 0, ha ez az > objektum nagyobb, mint CStringT (a kis- és psznagybetűket figyelmen kívül hagyva).

Megjegyzések

A fordításkor definiált karakterkészlettől függően az általános szövegfüggvény _tcsicmpa fordítási időpontban TCHAR.Hdefiniált karakterkészletre vagy _stricmpazokra lesz leképezve_wcsicmp_mbsicmp. Minden függvény a sztringek kis- és nagybetűk érzéketlen összehasonlítását végzi. Az összehasonlítás a LC_CTYPE területi beállítástól függ, de nem LC_COLLATE. További információ: _stricmp, _wcsicmp, _mbsicmp, _stricmp_l, _wcsicmp_l. _mbsicmp_l

példa

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

Egy CStringT objektumot hoz létre.

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

Paraméterek

pch
Mutató egy hosszú nLength, nem null értékű karaktertömbre.

nLength
A karakterek számának száma a következőben pch: .

ch
Egyetlen karakter.

pszSrc
Az objektumba CStringT másolandó null értékű sztring.

pStringMgr
Az objektum memóriakezelőjének CStringT mutatója. További információ a memóriakezelésről IAtlStringMgr és a memóriakezelésről CStringT: Memóriakezelés a CStringT használatával.

strSrc
Az objektumba CStringT másolandó meglévő CStringT objektum. További információt CThisStringCThisSimpleStringa Megjegyzések szakaszban talál.

varSrc
Ebbe az objektumba CStringT másolandó változatobjektum.

BaseType
A sztringosztály karaktertípusa. A következők egyike lehet:

char (ANSI-karaktersztringek esetén).

wchar_t (Unicode-karaktersztringek esetén).

TCHAR (ANSI- és Unicode-karaktersztringekhez egyaránt).

bMFCDLL
Logikai érték, amely meghatározza, hogy a projekt MFC DLL -e (TRUE) vagy sem (FALSE).

SystemString
Kell lennie System::String, és a projektet a következővel /clrkell lefordítani: .

pString
Egy objektum fogópontja CStringT .

Megjegyzések

Mivel a konstruktorok a bemeneti adatokat új lefoglalt tárolóba másolják, memóriakivételek következhetnek be. Ezen konstruktorok némelyike konverziós függvényként működik. Ez lehetővé teszi például LPTSTRCStringT egy objektum pótlását.

• CStringT(LPCSTRlpsz): Unicode-t CStringT hoz létre EGY ANSI-sztringből. Ezzel a konstruktorsal is betölthet egy sztringerőforrást az alábbi példában látható módon.

• CStringT(LPCWSTRlpsz): Unicode-sztringből hoz létre egy CStringT elemet.

• CStringT(const unsigned char*psz): Lehetővé teszi, hogy hozzon létre egy CStringT mutatót.unsigned char

Megjegyzés:

Adja meg a makrót az _CSTRING_DISABLE_NARROW_WIDE_CONVERSION ANSI és Unicode sztringek közötti implicit sztring-átalakítás kikapcsolásához. A makró kizárja az átalakítást támogató fordítási konstruktorokat.

A strSrc paraméter lehet egy CStringT vagy CThisSimpleString objektum. Ehhez CStringThasználja az egyik alapértelmezett példányt (CStringvagy CStringACStringW); a CThisSimpleStringmutatótthis. CThisSimpleString Deklarálja az CSimpleStringT osztály egy példányát, amely egy kisebb sztringosztály, amely kevésbé beépített funkciókkal rendelkezik, mint az CStringT osztály.

A túlterhelési operátor CSimpleStringT<>&() deklarációból CStringT hoz létre objektumot CSimpleStringT .

Megjegyzés:

Bár beágyazott null karaktereket tartalmazó példányok hozhatók létre CStringT , javasoljuk, hogy ellenük. A beágyazott null karaktereket tartalmazó objektumok metódusainak CStringT és operátorainak meghívása nem kívánt eredményeket eredményezhet.

példa

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

Elpusztítja az CStringT objektumot.

~CStringT() throw();

Megjegyzések

Elpusztítja az CStringT objektumot.

CStringT::Delete

Egy karaktert vagy karaktert töröl egy sztringből, kezdve az adott indexben lévő karakterrel.

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

Paraméterek

iIndex
A törölni kívánt objektum első karakterének CStringT nulla alapú indexe.

nCount
Az eltávolítandó karakterek száma.

Visszaadott érték

A módosított sztring hossza.

Megjegyzések

Ha nCount hosszabb, mint a sztring, a sztring többi része el lesz távolítva.

példa

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

Ebben a sztringben megkeresi egy karakter vagy alsztring első egyezését.

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

Paraméterek

pszSub
A kereséshez szükséges részszúrás.

iStart
A sztringben lévő karakter indexe a keresés megkezdéséhez, vagy 0 az elejétől kezdve.

ch
Egyetlen keresendő karakter.

Visszaadott érték

Az objektum első karakterének CStringT nulla alapú indexe, amely megfelel a kért részstringnek vagy karakternek; -1, ha az alsztring vagy a karakter nem található.

Megjegyzések

A függvény túlterhelt, hogy fogadja el az egykaraktert (a futásidejű függvényhez strchrhasonlóan) és a sztringeket is (hasonló).strstr

példa

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

Ebben a sztringben megkeresi az első karaktert, amely megfelel a benne található karaktereknek pszCharSet.

int FindOneOf(PCXSTR pszCharSet) const throw();

Paraméterek

pszCharSet
Karakterlánc, amely karaktereket tartalmaz az egyeztetéshez.

Visszaadott érték

A sztring első karakterének nulla alapú indexe, amely szintén benne pszCharSetvan; -1, ha nincs egyezés.

Megjegyzések

A bármelyik karakterének első előfordulását keresi meg.pszCharSet

példa

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

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

CStringT::Format

A formázott adatokat CStringT ugyanúgy írja le, mint sprintf_s egy C stílusú karaktertömböt.

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

Paraméterek

nFormatID
A formátumvezérlő sztringet tartalmazó sztringerőforrás-azonosító.

pszFormat
Formátumvezérlő sztring.

argument
Nem kötelező argumentumok.

Megjegyzések

Ez a függvény karakterek és értékek sorozatát formázja és tárolja a CStringTfájlban. Az egyes választható argumentumok (ha vannak ilyenek) konvertálása és kimenete a megfelelő formátumspecifikációnak megfelelően történik az általuk azonosított sztringerőforrásban pszFormatnFormatIDvagy -forrásból.

A hívás sikertelen lesz, ha maga a sztringobjektum paraméterként van felajánlva.Format A következő kód például kiszámíthatatlan eredményeket fog eredményezni:

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

További információ: Formátumspecifikáció szintaxisa: printf és wprintf Függvények.

példa

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

Üzenetsztring formázása.

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

Paraméterek

nFormatID
A formázatlan üzenetszöveget tartalmazó sztringerőforrás-azonosító.

pszFormat
A formátumvezérlő sztringre mutat. A program beolvasja a beszúrásokat, és ennek megfelelően formázza. A formátumsztring hasonló a futásidejű függvény printf-stílusú formázási sztringekhez, de lehetővé teszi a paraméterek tetszőleges sorrendbe való beszúrását.

argument
Nem kötelező argumentumok.

Megjegyzések

A függvény bemenetként üzenetdefiníciót igényel. Az üzenetdefiníciót a megadott sztringerőforrás pszFormatnFormatIDhatározza meg. A függvény átmásolja a formázott üzenetszöveget az objektumba, és szükség esetén feldolgozza a CStringT beágyazott beszúrási sorozatokat.

Megjegyzés:

FormatMessage megpróbálja lefoglalni a rendszermemóriát az újonnan formázott sztringhez. Ha ez a kísérlet sikertelen, a rendszer automatikusan memóriakivételt jelez.

Minden beszúrásnak rendelkeznie kell egy megfelelő paraméterrel a vagy pszFormat paraméter nFormatID után. Az üzenet szövegében számos feloldósorozat támogatott az üzenet dinamikus formázásához. További információ: Windows FormatMessage függvény a Windows SDK-ban.

példa

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

Üzenetsztring formázása változó argumentumlistával.

void FormatMessageV(PCXSTR pszFormat, va_list* pArgList);

Paraméterek

pszFormat
A formátumvezérlő sztringre mutat. A program beolvasja a beszúrásokat, és ennek megfelelően formázza. A formátumsztring hasonló a futásidejű függvény printf-stílusú formázási sztringekhez, de lehetővé teszi a paraméterek tetszőleges sorrendbe való beszúrását.

pArgList
Mutató az argumentumok listájára.

Megjegyzések

A függvény bemenetként egy üzenetdefiníciót igényel, amelyet a pszFormatfüggvény határoz meg. A függvény átmásolja a formázott üzenetszöveget és az argumentumok változólistáját az objektumba, és szükség esetén feldolgozza a CStringT beágyazott beszúrási sorozatokat.

Megjegyzés:

FormatMessageV hívásokat CStringT::FormatMessage, amelyek megkísérlik lefoglalni a rendszermemóriát az újonnan formázott sztringhez. Ha ez a kísérlet sikertelen, a rendszer automatikusan memóriakivételt jelez.

További információ: Windows FormatMessage függvény a Windows SDK-ban.

CStringT::FormatV

Üzenetsztring formázása változó argumentumlistával.

void FormatV(PCXSTR pszFormat, va_list args);

Paraméterek

pszFormat
A formátumvezérlő sztringre mutat. A program beolvasja a beszúrásokat, és ennek megfelelően formázza. A formátumsztring hasonló a futásidejű függvény printf-stílusú formázási sztringekhez, de lehetővé teszi a paraméterek tetszőleges sorrendbe való beszúrását.

args
Mutató az argumentumok listájára.

Megjegyzések

Formázott sztringet és argumentumok változólistáját ugyanúgy írja egy sztringbe CStringT , ahogyan vsprintf_s az adatokat C stílusú karaktertömbbe formázza.

példa

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

A sztringet a megadott környezeti változó értékére állítja.

BOOL GetEnvironmentVariable(PCXSTR pszVar);

Paraméterek

pszVar
Mutasson egy null értékű sztringre, amely megadja a környezeti változót.

Visszaadott érték

Nonzero, ha sikeres; egyéb esetben 0.

Megjegyzések

Lekéri a megadott változó értékét a hívási folyamat környezeti blokkjából. Az érték null értékű karaktersorozat formájában van megadva.

példa

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

Egyetlen karaktert vagy alsztringet szúr be az adott indexbe a sztringen belül.

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

Paraméterek

iIndex
Annak a karakternek az indexe, amely előtt a beszúrás megtörténik.

psz
A beszúrni kívánt részszúrás mutatója.

ch
A beszúrandó karakter.

Visszaadott érték

A módosított sztring hossza.

Megjegyzések

A iIndex paraméter azonosítja az első karaktert, amelyet áthelyez, hogy helyet biztosítson a karakternek vagy az alsztringnek. Ha nIndex nulla, a beszúrás a teljes sztring előtt történik. Ha az nIndex nagyobb, mint a sztring hossza, a függvény összefűzi a jelenlegi sztringet és az új anyagot, amelyet vagy ch a psz.

példa

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

Kinyeri a bal szélső nCount karaktereket ebből az CStringT objektumból, és visszaadja a kinyert részszúrás másolatát.

CStringT Left(int nCount) const;

Paraméterek

nCount
Az objektumból CStringT kinyerendő karakterek száma.

Visszaadott érték

Egy CStringT objektum, amely a megadott karaktertartomány másolatát tartalmazza. Előfordulhat, hogy a visszaadott CStringT objektum üres.

Megjegyzések

Ha nCount meghaladja a sztring hosszát, a teljes sztring ki lesz nyerve. Left hasonló az Alapszintű Left függvényhez.

A több bájtos karakterkészletek (MBCS) nCount minden 8 bites sorozatot karakterként kezelnek, így nCount a több bájtos karakterek száma kettővel megszorozva lesz.

példa

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

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

CStringT::LoadString

Beolvassa az nID által azonosított Windows-sztringerőforrást egy meglévő CStringT objektumba.

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

Paraméterek

hInstance
A modul példányának leírója.

nID
Egy Windows-sztring erőforrás-azonosítója.

wLanguageID
A sztringerőforrás nyelve.

Visszaadott érték

Nem, ha az erőforrás-terhelés sikeres volt; egyéb esetben 0.

Megjegyzések

Betölti a sztringerőforrást (nID) a megadott modulból (hInstance) a megadott nyelvvel (wLanguage).

példa

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

CAtlString s;
s.LoadString(IDS_APP_TITLE);   

CStringT::MakeLower

Az objektumot kisbetűs CStringT sztringgé alakítja.

CStringT& MakeLower();

Visszaadott érték

Az eredményül kapott kisbetűs sztring.

példa

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

CAtlString s(_T("ABC"));

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

CStringT::MakeReverse

Megfordítja az objektumban lévő karakterek sorrendjét CStringT .

CStringT& MakeReverse();

Visszaadott érték

Az eredményül kapott fordított sztring.

példa

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

CAtlString s(_T("abc"));

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

CStringT::MakeUpper

Az objektumot nagybetűs CStringT sztringgé alakítja.

CStringT& MakeUpper();

Visszaadott érték

Az eredményül kapott nagybetűs sztring.

Megjegyzések

példa

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

CAtlString s(_T("abc"));

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

CStringT::Mid

Kinyeri a hosszkaraktereket nCount ebből az CStringT objektumból, a pozíciótól iFirst kezdve (nulla-alapú).

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

Paraméterek

iFirst
Az objektum első karakterének CStringT nullaalapú indexe, amelyet a kinyert részszűrés tartalmaz.

nCount
Az objektumból CStringT kinyerendő karakterek száma. Ha ez a paraméter nincs megadva, a rendszer kinyeri a sztring többi részét.

Visszaadott érték

Egy CStringT objektum, amely a megadott karaktertartomány másolatát tartalmazza. Előfordulhat, hogy a visszaadott CStringT objektum üres.

Megjegyzések

A függvény visszaadja a kinyert részszúrás másolatát. Mid hasonló az Alapszintű közép függvényhez (azzal a kivételel, hogy az Alapszintű indexek egy-alapúak).

A többbájtos karakterkészletek (MBCS) nCount minden 8 bites karakterre vonatkoznak, vagyis egy többbájtos karakterben az érdeklődő és a nyomvonal bájtja két karakternek számít.

példa

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

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

CStringT::OemToAnsi

Az objektum összes karakterét CStringT átalakítja az OEM-karakterkészletből az ANSI-karakterkészletbe.

void OemToAnsi();

Megjegyzések

Ez a függvény nem érhető el, ha _UNICODE definiálva van.

példa

Lásd a példát a CStringT::AnsiToOem.

CStringT::operator =

Új értéket rendel a sztringhez.

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

Paraméterek

strSrc
A CStringT a sztringhez rendelhető.

str
Hivatkozás egy CThisSimpleString objektumra.

bMFCDLL
Logikai érték, amely meghatározza, hogy a projekt MFC DLL-e vagy sem.

BaseType
A sztring alaptípusa.

var
A sztringhez hozzárendelendő variánsobjektum.

ch
A sztringhez hozzárendelendő ANSI- vagy Unicode-karakter.

pszSrc
Mutató a hozzárendelt eredeti sztringre.

Megjegyzések

A hozzárendelési operátor egy másik CStringT objektumot, egy karaktermutatót vagy egy karaktert fogad el. Memóriakivételek akkor fordulhatnak elő, ha ezt az operátort használja, mert új tárterületet lehet lefoglalni.

További információkért CThisSimpleStringlásd a Megjegyzések szakaszt CStringT::CStringT.

Megjegyzés:

Bár beágyazott null karaktereket tartalmazó példányok hozhatók létre CStringT , javasoljuk, hogy ellenük. A beágyazott null karaktereket tartalmazó objektumok metódusainak CStringT és operátorainak meghívása nem kívánt eredményeket eredményezhet.

CStringT::operator +

Összefűz két sztringet vagy egy karaktert és egy sztringet.

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

Paraméterek

ch1
Egy ANSI- vagy Unicode-karakter, amely sztringgel összefűzendő.

ch2
Egy ANSI- vagy Unicode-karakter, amely sztringgel összefűzendő.

str1
A CStringT sztringgel vagy karakterrel összefűzendő.

str2
A CStringT sztringgel vagy karakterrel összefűzendő.

psz1
Egy null értékű sztringre mutató mutató, amely összefűz egy sztringgel vagy karakterrel.

psz2
Egy sztringre mutató mutató, amely összefűz egy sztringgel vagy karakterrel.

Megjegyzések

A függvénynek hét túlterhelési CStringT::operator+ formája van. Az első verzió két meglévő CStringT objektumot fűz össze. A következő kettő összefűz egy CStringT objektumot és egy null értékű sztringet. A következő kettő összefűz egy CStringT objektumot és egy ANSI-karaktert. Az utolsó kettő összefűz egy CStringT objektumot és egy Unicode-karaktert.

Megjegyzés:

Bár beágyazott null karaktereket tartalmazó példányok hozhatók létre CStringT , javasoljuk, hogy ellenük. A beágyazott null karaktereket tartalmazó objektumok metódusainak CStringT és operátorainak meghívása nem kívánt eredményeket eredményezhet.

példa

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

Összefűzi a karaktereket a sztring végéig.

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

Paraméterek

str
Hivatkozás egy CThisSimpleString objektumra.

bMFCDLL
Logikai érték, amely meghatározza, hogy a projekt MFC DLL-e vagy sem.

BaseType
A sztring alaptípusa.

var
A sztringhez fűzendő variánsobjektum.

ch
Egy ANSI- vagy Unicode-karakter, amely sztringgel összefűzendő.

pszSrc
Az összefűzött eredeti sztringre mutató mutató.

strSrc
A CStringT a sztring összefűzéséhez.

Megjegyzések

Az operátor egy másik CStringT objektumot, egy karaktermutatót vagy egy karaktert fogad el. Memóriakivételek akkor fordulhatnak elő, ha ezt az összefűzési operátort használja, mert az objektumhoz CStringT hozzáadott karakterek számára új tárterület foglalható le.

További információkért CThisSimpleStringlásd a Megjegyzések szakaszt CStringT::CStringT.

Megjegyzés:

Bár beágyazott null karaktereket tartalmazó példányok hozhatók létre CStringT , javasoljuk, hogy ellenük. A beágyazott null karaktereket tartalmazó objektumok metódusainak CStringT és operátorainak meghívása nem kívánt eredményeket eredményezhet.

példa

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

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

CStringT::operator ==

Meghatározza, hogy két sztring logikailag egyenlő-e.

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

Paraméterek

ch1
ANSI- vagy Unicode-karakter összehasonlításhoz.

ch2
ANSI- vagy Unicode-karakter összehasonlításhoz.

str1
A CStringT az összehasonlításhoz.

str2
A CStringT az összehasonlításhoz.

psz1
Mutató egy null értékű sztringre összehasonlítás céljából.

psz2
Mutató egy null értékű sztringre összehasonlítás céljából.

Megjegyzések

Azt ellenőrzi, hogy a bal oldalon lévő sztring vagy karakter egyenlő-e a jobb oldalon lévő sztringgel vagy karakterrel, és visszaadja TRUE vagy FALSE ennek megfelelően.

példa

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

Meghatározza, hogy két sztring logikailag nem egyenlő-e.

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

Paraméterek

ch1
Egy ANSI- vagy Unicode-karakter, amely sztringgel összefűzendő.

ch2
Egy ANSI- vagy Unicode-karakter, amely sztringgel összefűzendő.

str1
A CStringT az összehasonlításhoz.

str2
A CStringT az összehasonlításhoz.

psz1
Mutató egy null értékű sztringre összehasonlítás céljából.

psz2
Mutató egy null értékű sztringre összehasonlítás céljából.

Megjegyzések

Ellenőrzi, hogy a bal oldalon lévő sztring vagy karakter nem egyenlő-e a jobb oldalon lévő sztringgel vagy karakterrel.

példa

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

Meghatározza, hogy az operátor bal oldalán lévő sztring kisebb-e, mint a jobb oldalon lévő sztring.

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

Paraméterek

str1
A CStringT az összehasonlításhoz.

str2
A CStringT az összehasonlításhoz.

psz1
Mutató egy null értékű sztringre összehasonlítás céljából.

psz2
Mutató egy null értékű sztringre összehasonlítás céljából.

Megjegyzések

A sztringek lexikográfiai összehasonlítása karakter szerint a következőig:

• A függvény két megfelelő karaktert egyenlőtlennek talál, és az összehasonlítás eredménye a sztringek összehasonlítása lesz.

• Nem talál egyenlőtlenségeket, de az egyik sztring több karaktert tartalmaz, mint a másik, és a rövidebb sztring kisebb, mint a hosszabb sztring.

• Nem talál egyenlőtlenségeket, és megállapítja, hogy a sztringek száma azonos, így a sztringek egyenlőek.

példa

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

Meghatározza, hogy az operátor bal oldalán lévő sztring nagyobb-e, mint a jobb oldalon lévő sztring.

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

Paraméterek

str1
A CStringT az összehasonlításhoz.

str2
A CStringT az összehasonlításhoz.

psz1
Mutató egy null értékű sztringre összehasonlítás céljából.

psz2
Mutató egy null értékű sztringre összehasonlítás céljából.

Megjegyzések

A sztringek lexikográfiai összehasonlítása karakter szerint a következőig:

• A függvény két megfelelő karaktert egyenlőtlennek talál, és az összehasonlítás eredménye a sztringek összehasonlítása lesz.

• Nem talál egyenlőtlenségeket, de az egyik sztring több karaktert tartalmaz, mint a másik, és a rövidebb sztring kisebb, mint a hosszabb sztring.

• Nem talál egyenlőtlenségek, és megállapítja, hogy a sztringek száma azonos, így a sztringek egyenlőek.

példa

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

Meghatározza, hogy az operátor bal oldalán lévő sztring kisebb vagy egyenlő-e a jobb oldalon lévő sztringgel.

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

Paraméterek

str1
A CStringT az összehasonlításhoz.

str2
A CStringT az összehasonlításhoz.

psz1
Mutató egy null értékű sztringre összehasonlítás céljából.

psz2
Mutató egy null értékű sztringre összehasonlítás céljából.

Megjegyzések

A sztringek lexikográfiai összehasonlítása karakter szerint a következőig:

• A függvény két megfelelő karaktert egyenlőtlennek talál, és az összehasonlítás eredménye a sztringek összehasonlítása lesz.

• Nem talál egyenlőtlenségeket, de az egyik sztring több karaktert tartalmaz, mint a másik, és a rövidebb sztring kisebb, mint a hosszabb sztring.

• Nem talál egyenlőtlenségek, és megállapítja, hogy a sztringek száma azonos, így a sztringek egyenlőek.

példa

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

Meghatározza, hogy az operátor bal oldalán lévő sztring nagyobb vagy egyenlő-e a jobb oldalon lévő sztringgel.

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

Paraméterek

str1
A CStringT az összehasonlításhoz.

str2
A CStringT az összehasonlításhoz.

psz1
Mutató egy sztringre összehasonlítás céljából.

psz2
Mutató egy sztringre összehasonlítás céljából.

Megjegyzések

A sztringek lexikográfiai összehasonlítása karakter szerint a következőig:

• A függvény két megfelelő karaktert egyenlőtlennek talál, és az összehasonlítás eredménye a sztringek összehasonlítása lesz.

• Nem talál egyenlőtlenségeket, de az egyik sztring több karaktert tartalmaz, mint a másik, és a rövidebb sztring kisebb, mint a hosszabb sztring.

• Nem talál egyenlőtlenségek, és megállapítja, hogy a sztringek száma azonos, így a sztringek egyenlőek.

példa

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

Eltávolítja a megadott karakter összes példányát a sztringből.

int Remove(XCHAR chRemove);

Paraméterek

chRemove
A sztringből eltávolítandó karakter.

Visszaadott érték

A sztringből eltávolított karakterek száma. Nulla, ha a sztring nem változik.

Megjegyzések

A karakter összehasonlítása megkülönbözteti a kis- és nagybetűket.

példa

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

A .-nak Replacekét verziója van. Az első verzió egy vagy több alsztring egy vagy több példányát lecseréli egy másik alstring használatával. Mindkét részsztring null értékű. A második verzió egy karakter egy vagy több példányát lecseréli egy másik karakterre. Mindkét verzió a fájlban CStringTtárolt karakteradatokon működik.

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

Paraméterek

pszOld
A lecserélendő pszNewnull értékű sztringre mutató mutató.

pszNew
A lecserélt pszOldnull értékű sztringre mutató mutató.

chOld
A lecserélendő chNewkarakter.

chNew
A karakter cseréje chOld.

Visszaadott érték

A karakter vagy az alsztring lecserélt példányainak számát adja vissza, vagy nullát, ha a sztring nem változik.

Megjegyzések

Replace módosíthatja a sztring hosszát, mert pszNewpszOld nem kell azonos hosszúságúnak lennie, és a régi részsztring több példánya is módosítható az újra. A függvény megkülönbözteti a kis- és nagybetűk egyezését.

Példák például a CStringT következőkre CString: , CStringAés CStringW.

CStringA Ez esetben ReplaceANSI- vagy többbájtos (MBCS) karakterekkel működik. Mert CStringWszéles Replace karakterekkel működik.

Ebben CStringaz esetben a karakter adattípusa a fordításkor lesz kiválasztva attól függően, hogy az alábbi táblázatban szereplő állandók definiálva vannak-e.

Definiált állandó	Karakter adattípusa
_UNICODE	Széles karakterek
_MBCS	Több bájtos karakterek
Egyik sem	Egy bájtos karakterek
Mindkettő	Meghatározatlan

példa

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

Ebben az CStringT objektumban keres egy karakter utolsó egyezését.

int ReverseFind(XCHAR ch) const throw();

Paraméterek

ch
A keresendő karakter.

Visszaadott érték

Az objektum utolsó karakterének CStringT nulla alapú indexe, amely megfelel a kért karakternek, vagy -1, ha a karakter nem található.

Megjegyzések

A függvény hasonló a futásidejű függvényhez strrchr.

példa

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

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

CStringT::Right

Kinyeri az utolsó (vagyis a jobb szélső) nCount karaktereket ebből az CStringT objektumból, és visszaadja a kinyert részszúrás egy példányát.

CStringT Right(int nCount) const;

Paraméterek

nCount
Az objektumból CStringT kinyerendő karakterek száma.

Visszaadott érték

Egy CStringT objektum, amely a megadott karaktertartomány másolatát tartalmazza. A visszaadott CStringT objektum üres lehet.

Megjegyzések

Ha nCount meghaladja a sztring hosszát, a teljes sztring ki lesz nyerve. Right hasonló az Alapszintű Right függvényhez (kivéve, hogy az Alapszintű indexek nulla alapúak).

A többbájtos karakterkészletek (MBCS) nCount minden 8 bites karakterre vonatkoznak, vagyis egy többbájtos karakterben lévő érdeklődő és nyomvonal bájt két karakternek számít.

példa

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

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

CStringT::SetSysString

Újratelepíti a BSTR hivatkozott pbstr objektumot, és bemásolja az CStringT objektum tartalmát, beleértve a karaktert NULL is.

BSTR SetSysString(BSTR* pbstr) const;

Paraméterek

pbstr
Egy karaktersztringre mutató mutató.

Visszaadott érték

Az új sztring.

Megjegyzések

Az objektum tartalmától CStringT függően az általa BSTR hivatkozott érték pbstr változhat. A függvény nem rendelkezik CMemoryException elegendő memóriával.

Ezt a függvényt általában az Automation hivatkozása által átadott sztringek értékének módosítására használják.

példa

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

Kinyeri a sztringből az első karakterrel kezdődő karaktereket, amelyek nem szerepelnek a megadott karakterkészletben pszCharSet.

CStringT SpanExcluding(PCXSTR pszCharSet) const;

Paraméterek

pszCharSet
Karakterkészletként értelmezett sztring.

Visszaadott érték

Olyan részsztring, amely a sztringben pszCharSetnem szereplő karaktereket tartalmaz, kezdve a sztring első karakterével, és a karakterláncban pszCharSet található első karakterrel végződik (vagyis a sztring első karakterétől kezdve egészen a talált pszCharSetkarakterlánc első karakterének kivételével). A teljes sztringet adja vissza, ha a sztringben pszCharSet nem található karakter.

Megjegyzések

SpanExcluding kinyeri és visszaadja a karakter pszCharSet első előfordulását megelőző összes karaktert (vagyis a karaktert pszCharSet a sztringben, és az azt követő összes karaktert nem adja vissza). Ha a sztringben nem található karakter pszCharSet , akkor SpanExcluding a teljes sztringet adja vissza.

példa

// 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("abcdef"));

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

CStringT::SpanIncluding

A sztringből kinyeri a karaktereket, kezdve az első karakterrel, amelyek az általuk azonosított pszCharSetkarakterkészletben találhatók.

CStringT SpanIncluding(PCXSTR pszCharSet) const;

Paraméterek

pszCharSet
Karakterkészletként értelmezett sztring.

Visszaadott érték

Olyan részsztring, amely a sztringben pszCharSetszereplő karaktereket tartalmazza, kezdve a sztring első karakterével, és akkor végződik, amikor egy karaktert talál a sztringben, amely nem szerepel a sztringben pszCharSet. SpanIncluding Üres részszúrást ad vissza, ha a sztring első karaktere nem szerepel a megadott készletben.

Megjegyzések

Ha a sztring első karaktere nem szerepel a karakterkészletben, akkor SpanIncluding egy üres sztringet ad vissza. Ellenkező esetben a készletben lévő egymást követő karakterek sorozatát adja vissza.

példa

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

A következő token keresése egy célsztringben

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

Paraméterek

pszTokens
Jogkivonat-elválasztókat tartalmazó sztring. Ezeknek a határolóknak a sorrendje nem fontos.

iStart
A keresés megkezdéséhez használt nulla alapú index.

Visszaadott érték

Az CStringT aktuális jogkivonat értékét tartalmazó objektum.

Megjegyzések

A Tokenize függvény megkeresi a következő tokent a célsztringben. A karakterkészlet a pszTokens megtalálandó jogkivonat lehetséges elválasztóit határozza meg. A függvény minden hívása Tokenize a következő időpontban iStartkezdődik, kihagyja a kezdő elválasztójeleket, és visszaad egy CStringT objektumot, amely az aktuális jogkivonatot tartalmazza, amely a karakterek sztringje a következő elválasztó karakterig. Az érték iStart úgy frissül, hogy a záró elválasztó karaktert követő pozíció legyen, vagy -1, ha a sztring vége el lett érve. A célsztring többi részéből több jogkivonatot is fel lehet bontani egy hívássorozattal Tokenize, amelynek segítségével iStart nyomon követheti, hogy a sztringben hol kell olvasni a következő tokent. Ha nincs több jogkivonat, a függvény egy üres sztringet ad vissza, és iStart -1 értékre lesz állítva.

A CRT-tokenizálási függvényekkel strtok_s_strtok_s_lwcstok_sellentétben , , , _wcstok_s_l, _mbstok_s, _mbstok_s_lTokenize nem módosítja a célsztringet.

példa

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

A példa kimenete a következő:

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

CStringT::Trim

Levágja a sztring kezdő és záró karaktereit.

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

Paraméterek

chTarget
A levágandó cél karakter.

pszTargets
Mutató a levágandó célkarakterekből álló sztringre. A karakterek pszTargets összes kezdő és záró előfordulása ki lesz vágva az CStringT objektumból.

Visszaadott érték

A levágott sztringet adja vissza.

Megjegyzések

Eltávolítja az alábbiak egyikének összes kezdő és záró előfordulását:

• A megadott chTargetkarakter.

• A megadott sztringben pszTargetstalálható összes karakter.

• Szóköz.

példa

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

A példa kimenete a következő:

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

CStringT::TrimLeft

Bevezető karakterek levágása a sztringből.

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

Paraméterek

chTarget
A levágandó cél karakter.

pszTargets
Mutató a levágandó célkarakterekből álló sztringre. A karakterek pszTargets összes kezdő előfordulása ki lesz vágva az CStringT objektumból.

Visszaadott érték

Az eredményül kapott levágott sztring.

Megjegyzések

Eltávolítja az alábbiak egyikének összes kezdő és záró előfordulását:

• A megadott chTargetkarakter.

• A megadott sztringben pszTargetstalálható összes karakter.

• Szóköz.

példa

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

Levágja a sztring záró karaktereit.

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

Paraméterek

chTarget
A levágandó cél karakter.

pszTargets
Mutató a levágandó célkarakterekből álló sztringre. A program a karakterek pszTargets összes záró előfordulását levágja az CStringT objektumból.

Visszaadott érték

CStringT A levágott sztringet tartalmazó objektumot adja vissza.

Megjegyzések

Eltávolítja az alábbiak egyikének záró előfordulásait:

• A megadott chTargetkarakter.

• A megadott sztringben pszTargetstalálható összes karakter.

• Szóköz.

A CStringT& TrimRight(XCHAR chTarget) verzió egy karakterparamétert fogad el, és eltávolítja a karakter minden példányát a sztringadatok CStringT végéről. A sztring végétől kezdődik, és az előtér felé halad. Leáll, ha egy másik karaktert talál, vagy elfogy CStringT a karakteradatok száma.

A CStringT& TrimRight(PCXSTR pszTargets) verzió egy null értékű sztringet fogad el, amely tartalmazza az összes keresendő karaktert. Eltávolítja az objektumban lévő karakterek összes másolatát CStringT . A sztring végén kezdődik, és az előtér felé halad. Leáll, ha olyan karaktert talál, amely nem szerepel a célsztringben, vagy elfogy CStringT a karakteradatok száma. Nem próbálja a teljes célsztringet egy részsztringgel egyezni a végén CStringT.

A CStringT& TrimRight() verzió nem igényel paramétereket. A sztring végétől CStringT levágja a záró szóközkaraktereket. A szóköz karakterek lehetnek sortörések, szóközök vagy tabulátorok.

példa

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

Lásd még

hierarchiadiagram
ATL/MFC megosztott osztályok
CSimpleStringT osztály