CStringT Deník

Tato třída reprezentuje CStringT objekt.

Syntaxe

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

Parametry

BaseType
Typ znaku řetězcové třídy. Může to být jedna z následujících:

• char (pro řetězce znaků ANSI).

• wchar_t (pro řetězce znaků Unicode).

• TCHAR (pro řetězce znaků ANSI i Unicode).

StringTraits
Určuje, zda třída řetězce vyžaduje podporu knihovny jazyka C Run-Time (CRT) a kde jsou umístěny prostředky řetězců. Může to být jedna z následujících:

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

  Třída vyžaduje podporu CRT a hledá řetězce prostředků v modulu určeném m_hInstResource (členem třídy modulu aplikace).

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

  Třída nevyžaduje podporu CRT a hledá řetězce prostředků v modulu určeném m_hInstResource (členem třídy modulu aplikace).

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

  Třída vyžaduje podporu CRT a hledá řetězce prostředků pomocí standardního vyhledávacího algoritmu MFC.

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

  Třída nevyžaduje podporu CRT a hledá řetězce prostředků pomocí standardního vyhledávacího algoritmu MFC.

Členové

Veřejné konstruktory

Veřejné metody

Operátory

Poznámky

CStringTdědí z CStringT. Pokročilé funkce, jako je například manipulace se znaky, řazení a hledání, jsou implementovány nástrojem CStringT .

CStringTObjekt se skládá z sekvence znaků s proměnlivou délkou. CStringT poskytuje funkce a operátory pomocí syntaxe, která je podobná syntaxi Basic. Operátory zřetězení a porovnávání, společně s zjednodušenou správou paměti, usnadňují CStringT používání objektů než běžných polí znaků.

Pomocí různých kombinací BaseTypeStringTraits parametrů a CStringT mohou objekty přijít do následujících typů, které byly předdefinované knihovnami ATL.

Při použití v aplikaci ATL:

CString, CStringA , a CStringW jsou exportovány z knihovny MFC dll (MFC90.DLL), nikdy z knihoven DLL uživatele. Tím se zabrání CStringT v definování víckrát.

V aplikacích založených na knihovně MFC jsou k dispozici následující typy řetězců:

Následující typy řetězců jsou k dispozici v projektech, kde ATL_CSTRING_NO_CRT je definována:

Následující typy řetězců jsou k dispozici v projektech, kde ATL_CSTRING_NO_CRT nejsou definovány:

CString objekty mají také následující vlastnosti:

• CStringT objekty mohou růst z důvodu operací zřetězení.

• CStringT objekty následují jako "sémantika hodnoty". CStringTObjekt si můžete představit jako skutečný řetězec, nikoli jako ukazatel na řetězec.

• Můžete volně dosadit CStringT objekty pro PCXSTR argumenty funkce.

• Vlastní Správa paměti pro vyrovnávací paměti řetězců. Další informace najdete v tématu Správa paměti a .

Předdefinované typy CStringt

Vzhledem k tomu CStringT , že používá argument šablony pro definování typu znaku (buď wchar_t nebo char ), typy parametrů metody mohou být složité v časech. Pro zjednodušení tohoto problému je definována sada předdefinovaných typů, která se používá v celé CStringT třídě. V následující tabulce jsou uvedeny různé typy:

Hierarchie dědičnosti

CSimpleStringT

CStringT

Požadavky

CStringT::AllocSysString

Přidělí řetězec kompatibilní s automatizací typu BSTR a zkopíruje CStringT do něj obsah objektu, včetně ukončujícího znaku null.

BSTR AllocSysString() const;

Návratová hodnota

Nově přidělený řetězec.

Poznámky

V programech MFC je Třída vyvolána, pokud existuje nedostatek paměti. V programech ATL CAtlException je vyvolána výjimka. Tato funkce se obvykle používá k vrácení řetězců pro automatizaci.

Obecně platí, že pokud je tento řetězec předán funkci modelu COM jako [in] parametr, pak vyžaduje volající uvolnění řetězce. to lze provést pomocí SysFreeString , jak je popsáno v Windows SDK. Další informace najdete v tématu přidělování a uvolňování paměti pro .

další informace o funkcích alokace OLE v Windows naleznete v části SysAllocString v Windows SDK.

Příklad

Následující příklad ukazuje použití 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

Převede všechny znaky v tomto CStringT objektu ze znakové sady ANSI na znakovou sadu OEM.

void AnsiToOem();

Poznámky

Funkce není k dispozici, pokud _UNICODE je definována.

Příklad

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

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

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

CStringT::AppendFormat

Připojí formátovaná data k existujícímu CStringT objektu.

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

Parametry

pszFormat
Řetězec řízení formátu.

nFormatID
Identifikátor prostředku řetězce, který obsahuje řetězec řízení formátu.

argument
Volitelné argumenty

Poznámky

Tato funkce formátuje a připojuje řadu znaků a hodnot v CStringT . Každý volitelný argument (pokud existuje) je převeden a připojen podle odpovídající specifikace formátu v pszFormat nebo z prostředku řetězce identifikovaného nFormatID .

Příklad

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

Porovná dva řetězce pomocí funkce obecného textu _tcscoll .

int Collate(PCXSTR psz) const throw();

Parametry

psz
Druhý řetězec použitý pro porovnání.

Návratová hodnota

Nula, pokud jsou řetězce identické, < 0, pokud CStringT je tento objekt menší psz nebo > 0, pokud CStringT je tento objekt větší než psz .

Poznámky

Funkce obecného textu _tcscoll , která je definována v, je TCHAR.H mapována na buď strcoll , wcscoll nebo _mbscoll , v závislosti na znakové sadě, která je definována v době kompilace. Každá funkce rozlišuje velká a malá písmena řetězců podle znakové stránky, která se právě používá. Další informace naleznete v tématu , wcscoll , _mbscoll , _strcoll_l , _wcscoll_l , _mbscoll_l.

CStringT::CollateNoCase

Porovná dva řetězce pomocí funkce obecného textu _tcscoll .

int CollateNoCase(PCXSTR psz) const throw();

Parametry

psz
Druhý řetězec použitý pro porovnání.

Návratová hodnota

Nula, pokud jsou řetězce identické (ignorování velkých a malých písmen), < 0, pokud CStringT je tento objekt menší než psz (ignorování velkých a malých písmen), nebo > 0, pokud CStringT je tento objekt větší než psz (ignorování velkých a malých písmen).

Poznámky

Funkce obecného textu _tcscoll , která je definována v, je TCHAR.H mapována na buď stricoll , wcsicoll nebo _mbsicoll , v závislosti na znakové sadě, která je definována v době kompilace. Každá funkce provede porovnání řetězců bez rozlišování velkých a malých písmen, podle znakové stránky, která se právě používá. Další informace naleznete v tématu , wcscoll , _mbscoll , _strcoll_l , _wcscoll_l , _mbscoll_l.

Příklad

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

Porovná dva řetězce (rozlišuje velká a malá písmena).

int Compare(PCXSTR psz) const;

Parametry

psz
Druhý řetězec použitý pro porovnání.

Návratová hodnota

Nula, pokud jsou řetězce identické, < 0, pokud CStringT je tento objekt menší psz nebo > 0, pokud CStringT je tento objekt větší než psz .

Poznámky

Funkce obecného textu _tcscmp , která je definována v, je TCHAR.H mapována na buď strcmp , wcscmp nebo _mbscmp , v závislosti na znakové sadě, která je definována v době kompilace. Každá funkce rozlišuje velká a malá písmena řetězců a není ovlivněna národním prostředím. Další informace naleznete v tématu , wcscmp , _mbscmp.

Pokud řetězec obsahuje vložené hodnoty null, pro účely porovnání je řetězec považován za zkrácený při prvním vloženém znaku null.

Příklad

Následující příklad ukazuje použití 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

Porovná dva řetězce (bez rozlišení velkých a malých písmen).

int CompareNoCase(PCXSTR psz) const throw();

Parametry

psz
Druhý řetězec použitý pro porovnání.

Návratová hodnota

Nula, pokud jsou řetězce identické (ignorování velkých a malých písmen), < 0, pokud CStringT je tento objekt menší než psz (ignorování velkých a malých písmen), nebo > 0, pokud CStringT je tento objekt větší než psz (ignorování velkých a malých písmen).

Poznámky

Funkce obecného textu, která je definována v , se mapuje na , nebo , v závislosti na znakové sadě, která _tcsicmpTCHAR.H je _stricmp_wcsicmp_mbsicmp definována v době kompilace. Každá funkce neprovádá porovnání řetězců bez rozlišení velkých a malých písmen. Porovnání závisí na LC_CTYPE aspektu národního prostředí, ale ne na LC_COLLATE . Další informace najdete v tématu , , , , _wcsicmp_mbsicmp , _stricmp_l_wcsicmp_l . _mbsicmp_l

Příklad

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

Vytvoří 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);

Parametry

pch
Ukazatel na pole znaků o délce nLength , nikoli na hodnotu null ukončenou.

nLength
Počet znaků v pch .

ch
Jeden znak.

pszSrc
Řetězec zakončený hodnotou null, který se má zkopírovat do tohoto CStringT objektu.

pStringMgr
Ukazatel na správce paměti pro CStringT objekt. Další informace o správě paměti IAtlStringMgr pro najdete v tématu Správa paměti pomocí CStringTIAtlStringMgr

strSrc
Existující CStringT objekt, který se má zkopírovat do tohoto CStringT objektu. Další informace o a CThisStringCThisSimpleString najdete v části Poznámky.

varSrc
Variantní objekt, který má být zkopírován do tohoto CStringT objektu.

BaseType
Typ znaku třídy řetězce. Může to být jedna z následujících možností:

char (pro řetězce znaků ANSI).

wchar_t (pro řetězce znaků Unicode).

TCHAR (pro řetězce znaků ANSI i Unicode).

bMFCDLL
Logická hodnota, která určuje, zda je projekt knihovny MFC DLL ( TRUE ) nebo ne ( FALSE ).

SystemString
Musí být System::String a projekt musí být zkompilován pomocí /clr .

pString
Popisovač CStringT objektu.

Poznámky

Vzhledem k tomu, že konstruktory zkopírují vstupní data do nového přiděleného úložiště, může dojít k výjimce paměti. Některé z těchto konstruktorů slouží jako převodní funkce. To vám umožní nahradit například objekt , LPTSTR kde CStringT se očekává objekt.

• CStringT( LPCSTRlpsz ): Vytvoří unicode z CStringT řetězce ANSI. Tento konstruktor můžete použít také k načtení řetězcového prostředku, jak je znázorněno v následujícím příkladu.

• CStringT(LPCWSTRlpsz ): Vytvoří z CStringT řetězce Unicode.

• CStringT( const unsigned char*psz ): Umožňuje vytvořit objekt z ukazatele CStringT na unsigned char .

Parametr strSrc může být buď objekt , nebo CStringTCThisSimpleString . Pro CStringT použijte jednu z jeho výchozích instancí ( , nebo ); pro použijte CStringCStringACStringWCThisSimpleStringthis ukazatel. CThisSimpleStringdeklaruje instanci CThisSimpleString, což je menší řetězcová třída s méně integrovanou funkcí než CStringT třída .

Operátor přetížení CSimpleStringT<>&() vytvoří objekt z CStringTCSimpleStringT deklarace.

Příklad

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

Zničí CStringT objekt .

~CStringT() throw();

Poznámky

Zničí CStringT objekt .

CStringT::Delete

Odstraní znak nebo znaky z řetězce začínajícího znakem v daném indexu.

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

Parametry

iIndex
Index prvního znaku v objektu, který se má odstranit, od CStringT nuly.

nCount
Počet znaků, které se má odebrat.

Návratová hodnota

Délka změněných řetězců.

Poznámky

Pokud nCount je hodnota delší než řetězec, zbytek řetězce se odebere.

Příklad

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

Vyhledá v tomto řetězci první shodu znaku nebo podřetězce.

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

Parametry

pszSub
Podřetězec, který se má vyhledat.

iStart
Index znaku v řetězci, se který má začít hledat, nebo 0 pro začátek od začátku.

ch
Jeden znak, který se má vyhledat.

Návratová hodnota

Index prvního znaku v tomto objektu od nuly, který odpovídá požadovanému podřetězci nebo znakům; -1, pokud nebyl nalezen podřetězec CStringT nebo znak.

Poznámky

Funkce je přetížená tak, aby přijímal jednotlivé znaky (podobně jako funkce za běhu) i řetězce strchr (podobně jako strstr ).

Příklad

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

Vyhledá v tomto řetězci první znak, který odpovídá libovolnému znaku obsaženému v pszCharSet .

int FindOneOf(PCXSTR pszCharSet) const throw();

Parametry

pszCharSet
Řetězec obsahující znaky pro porovnávání.

Návratová hodnota

Index prvního znaku v tomto řetězci založený na nule, který je také v řetězci pszCharSet ; -1, pokud není nalezena žádná shoda.

Poznámky

Vyhledá první výskyt jakéhokoli znaku v pszCharSet .

Příklad

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

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

CStringT::Format

Zapisuje formátovaná data do objektu stejným způsobem, který formátuje data do pole znaků CStringTsprintf_s ve stylu jazyka C.

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

Parametry

nFormatID
Identifikátor prostředku řetězce, který obsahuje řetězec pro řízení formátu.

pszFormat
Řetězec pro řízení formátu.

argument
Volitelné argumenty

Poznámky

Tato funkce formátuje a ukládá řadu znaků a hodnot v CStringT objektu . Každý volitelný argument (pokud existuje) se převede a vystupuje podle odpovídající specifikace formátu v řetězci nebo z prostředku pszFormat řetězce identifikované parametrem nFormatID .

Volání selže, pokud je samotný objekt řetězce nabízen jako parametr pro Format . Například následující kód způsobí nepředvídatelné výsledky:

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

Další informace najdete v tématu Syntaxe specifikace formátu: a wprintf Funkce.

Příklad

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

Formátuje řetězec zprávy.

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

Parametry

nFormatID
Identifikátor prostředku řetězce, který obsahuje neformátovaný text zprávy.

pszFormat
Odkazuje na řídicí řetězec formátu. Naskenuje se vložení a naformátuje se odpovídajícím způsobem. Formátovací řetězec se podobá řetězcům formátu funkce run-time -style s tím rozdílem, že umožňuje vkládání parametrů printf v libovolném pořadí.

argument
Volitelné argumenty

Poznámky

Funkce vyžaduje jako vstup definici zprávy. Definice zprávy je určena pomocí pszFormat nebo z řetězcového prostředku identifikované pomocí nFormatID . Funkce zkopíruje formátovaný text zprávy do objektu a v případě požadavku zkopíruje všechny vložené CStringT sekvence vložení.

Každé vložení musí mít odpovídající parametr za pszFormat parametrem nFormatID nebo . V textu zprávy je několik řídicích sekvencí podporováno pro dynamické formátování zprávy. další informace najdete v tématu funkce Windows FormatMessage v Windows SDK.

Příklad

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

Formátuje řetězec zprávy pomocí seznamu argumentů proměnných.

void FormatMessageV(PCXSTR pszFormat, va_list* pArgList);

Parametry

pszFormat
Odkazuje na řetězec řízení formátu. Bude prohledáván pro odpovídající vložení a formátování. Formátovací řetězec je podobný printf formátovacím řetězcům ve stylu běhu, s výjimkou umožňuje vložení parametrů v libovolném pořadí.

pArgList
Ukazatel na seznam argumentů.

Poznámky

Funkce vyžaduje definici zprávy jako vstup, kterou Určuje pszFormat . Funkce zkopíruje text formátované zprávy a seznam argumentů s proměnnými do CStringT objektu a zpracovává všechny vložené sekvence vložení, pokud je to požadováno.

další informace najdete v tématu funkce Windows FormatMessage v Windows SDK.

CStringT::FormatV

Formátuje řetězec zprávy pomocí seznamu argumentů proměnných.

void FormatV(PCXSTR pszFormat, va_list args);

Parametry

pszFormat
Odkazuje na řetězec řízení formátu. Bude prohledáván pro odpovídající vložení a formátování. Formátovací řetězec je podobný printf formátovacím řetězcům ve stylu běhu, s výjimkou umožňuje vložení parametrů v libovolném pořadí.

args
Ukazatel na seznam argumentů.

Poznámky

Zapíše formátovaný řetězec a seznam proměnných argumentů do CStringT řetězce stejným způsobem, který vsprintf_s formátuje data do pole znaků ve stylu jazyka C.

Příklad

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

Nastaví řetězec na hodnotu zadané proměnné prostředí.

BOOL GetEnvironmentVariable(PCXSTR pszVar);

Parametry

pszVar
Ukazatel na řetězec zakončený hodnotou null, který určuje proměnnou prostředí.

Návratová hodnota

Nenulové, pokud bylo úspěšné; v opačném případě 0.

Poznámky

Načte hodnotu zadané proměnné z bloku prostředí volajícího procesu. Hodnota je ve formátu řetězce znaků zakončeného hodnotou null.

Příklad

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

Vloží jeden znak nebo podřetězec na daný index v rámci řetězce.

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

Parametry

iIndex
Index znaku, před kterým bude provedeno vkládání.

psz
Ukazatel na dílčí řetězec, který má být vložen.

ch
Znak, který má být vložen.

Návratová hodnota

Délka změněného řetězce.

Poznámky

iIndexParametr určuje první znak, který bude přesunut, aby uvolnil místo pro daný znak nebo podřetězec. Pokud nIndex je nula, vložení proběhne před celým řetězcem. Pokud je nIndex větší než délka řetězce, funkce bude zřetězit aktuální řetězec a nový materiál poskytnutý buď nebo psz .

Příklad

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

Extrahuje nCount z tohoto objektu znaky umístěné nejvíce vlevo CStringT a vrátí kopii extrahované podřetězce.

CStringT Left(int nCount) const;

Parametry

nCount
Počet znaků, které mají být z tohoto CStringT objektu extrahovány.

Návratová hodnota

CStringTObjekt, který obsahuje kopii zadaného rozsahu znaků. Vrácený CStringT objekt může být prázdný.

Poznámky

Pokud nCount přesahuje délku řetězce, je extrahován celý řetězec. Left je podobný základní Left funkci.

U vícebajtových znakových sad (MBCS) nCount zpracovává každou 8bitové sekvenci jako znak, takže nCount vrátí počet vícebajtových znaků vynásobený dvěma.

Příklad

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

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

CStringT::LoadString

přečte prostředek Windowsového řetězce identifikovaný nIDdo existujícího objektu.

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

Parametry

hInstance
Popisovač instance modulu.

nID
ID prostředku Windowsového řetězce.

wLanguageID
Jazyk řetězcového prostředku.

Návratová hodnota

Nenulové, pokud bylo zatížení prostředku úspěšné; v opačném případě 0.

Poznámky

Načte prostředek řetězce ( nID ) ze zadaného modulu () hInstance pomocí zadaného jazyka ( wLanguage ).

Příklad

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

CAtlString s;
s.LoadString(IDS_APP_TITLE);   

CStringT::MakeLower

Převede CStringT objekt na malý řetězec.

CStringT& MakeLower();

Návratová hodnota

Výsledný řetězec malými písmeny.

Příklad

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

CAtlString s(_T("ABC"));

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

CStringT::MakeReverse

Obrátí pořadí znaků v CStringT objektu.

CStringT& MakeReverse();

Návratová hodnota

Výsledný stornovaný řetězec.

Příklad

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

CAtlString s(_T("abc"));

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

CStringT::MakeUpper

Převede CStringT objekt na řetězec na velká písmena.

CStringT& MakeUpper();

Návratová hodnota

Výsledný řetězec na velká písmena.

Poznámky

Příklad

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

CAtlString s(_T("abc"));

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

CStringT::Mid

Extrahuje podřetězec znaků délky nCount z tohoto CStringT objektu, počínaje pozicí (počítáno od iFirst nuly).

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

Parametry

iFirst
Index založený na nule prvního znaku v tomto CStringT objektu, který má být zahrnut do extrahovaný podřetězec.

nCount
Počet znaků, které mají být z tohoto CStringT objektu extrahovány. Pokud tento parametr není zadán, bude extrahována zbývající část řetězce.

Návratová hodnota

CStringTObjekt, který obsahuje kopii zadaného rozsahu znaků. Vrácený CStringT objekt může být prázdný.

Poznámky

Funkce vrátí kopii extrahované podřetězce. Mid je podobný základní funkci Mid (s výjimkou toho, že indexy jsou založeny na bázi Basic).

Pro vícebajtové znakové sady (MBCS) nCount odkazuje na každý 8bitový znak; to znamená, že vedoucí a koncový bajt v jednom vícebajtovém znaku jsou počítány jako dva znaky.

Příklad

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

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

CStringT::OemToAnsi

Převede všechny znaky v tomto CStringT objektu ze znakové sady OEM na znakovou sadu ANSI.

void OemToAnsi();

Poznámky

Tato funkce není k dispozici _UNICODE , pokud je definována.

Příklad

Podívejte se na příklad pro CStringT::AnsiToOem .

CStringT::operator =

Přiřadí k řetězci novou hodnotu.

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

Parametry

strSrc
K CStringT přiřazení k tomuto řetězci.

str
Odkaz na CThisSimpleString objekt.

bMFCDLL
Logická hodnota určující, zda je projekt knihovny MFC DLL, nebo ne.

BaseType
Základní typ řetězce

var
Variantní objekt, který se má tomuto řetězci přiřadit.

ch
Znak ANSI nebo Unicode pro přiřazení k řetězci.

pszSrc
Ukazatel na původní přiřazený řetězec.

Poznámky

Operátor přiřazení přijímá jiný CStringT objekt, ukazatel na znak nebo jeden znak. K výjimce paměti může dojít při každém použití tohoto operátoru, protože je možné přidělit nové úložiště.

Informace o najdete CThisSimpleString v části Poznámky v tématu CStringT::CStringT .

CStringT::operator +

Zřetězí dva řetězce nebo znak a řetězec.

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

Parametry

ch1
Znak ANSI nebo Unicode pro zřetězit s řetězcem.

ch2
Znak ANSI nebo Unicode pro zřetězit s řetězcem.

str1
Pro CStringT zřetězit s řetězcem nebo znakem.

str2
Pro CStringT zřetězit s řetězcem nebo znakem.

psz1
Ukazatel na řetězec zakončený hodnotou null pro zřetězit s řetězcem nebo znakem.

psz2
Ukazatel na řetězec, který se má zřetězit s řetězcem nebo znakem.

Poznámky

Funkce má sedm forem CStringT::operator+ přetížení. První verze zřetězí dva existující CStringT objekty. Další dva objekty zřetězují CStringT a řetězec ukončený hodnotou null. Další dvě zřetězit objekt a CStringT znak ANSI. Poslední dvě zřetězit objekt CStringT a znak Unicode.

Příklad

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

Zřetězí znaky na konec řetězce.

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

Parametry

str
Odkaz na CThisSimpleString objekt.

bMFCDLL
Logická hodnota určující, zda je projekt knihovny MFC DLL, nebo ne.

BaseType
Základní typ řetězce

var
Variantní objekt, který se má zřetězit s tímto řetězcem.

ch
Znak ANSI nebo Unicode pro zřetězit s řetězcem.

pszSrc
Ukazatel na původní zřetězovaný řetězec.

strSrc
Pro CStringT zřetězit s tímto řetězcem.

Poznámky

Operátor přijímá jiný CStringT objekt, ukazatel na znak nebo jeden znak. K výjimce paměti může dojít vždy, když použijete tento operátor zřetězení, protože pro znaky přidané do tohoto objektu lze přidělit nové CStringT úložiště.

Informace o najdete CThisSimpleString v části Poznámky v tématu CStringT::CStringT .

Příklad

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

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

CStringT::operator ==

Určuje, zda jsou dva řetězce logicky stejné.

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

Parametry

ch1
Znak ANSI nebo Unicode pro porovnání.

ch2
Znak ANSI nebo Unicode pro porovnání.

str1
A CStringT pro porovnání.

str2
A CStringT pro porovnání.

psz1
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

psz2
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

Poznámky

Otestuje, jestli se řetězec nebo znak na levé straně rovná řetězci nebo znaku na pravé straně, a vrátí TRUE nebo FALSE odpovídajícím způsobem.

Příklad

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

Určuje, zda jsou dva řetězce logicky nerovny.

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

Parametry

ch1
Znak ANSI nebo Unicode pro zřetězit s řetězcem.

ch2
Znak ANSI nebo Unicode pro zřetězit s řetězcem.

str1
A CStringT pro porovnání.

str2
A CStringT pro porovnání.

psz1
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

psz2
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

Poznámky

Testuje, jestli se řetězec nebo znak na levé straně nerovná řetězci nebo znaku na pravé straně.

Příklad

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

Určuje, zda je řetězec na levé straně operátoru menší než řetězec na pravé straně.

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

Parametry

str1
A CStringT pro porovnání.

str2
A CStringT pro porovnání.

psz1
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

psz2
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

Poznámky

Lexikografické porovnání řetězců, znak po znaku, dokud:

• Najde dva odpovídající znaky nerovné a výsledek jejich porovnání se posouvá jako výsledek porovnání mezi řetězci.

• Nenajde žádné nerovnosti, ale jeden řetězec má více znaků než druhý a kratší řetězec je považován za menší než delší řetězec.

• Nenajde žádné nerovnosti a zjistí, že řetězce mají stejný počet znaků, a proto se řetězce rovnají.

Příklad

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

Určuje, zda je řetězec na levé straně operátoru větší než řetězec na pravé straně.

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

Parametry

str1
A CStringT pro porovnání.

str2
A CStringT pro porovnání.

psz1
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

psz2
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

Poznámky

Lexikografické porovnání řetězců, znak po znaku, dokud:

• Najde dva odpovídající znaky nerovné a výsledek jejich porovnání se posouvá jako výsledek porovnání mezi řetězci.

• Nenajde žádné nerovnosti, ale jeden řetězec má více znaků než druhý a kratší řetězec je považován za menší než delší řetězec.

• Nenajde žádné nerovnosti a zjistí, že řetězce mají stejný počet znaků, takže řetězce jsou si rovny.

Příklad

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

Určuje, zda je řetězec na levé straně operátoru menší nebo roven řetězci na pravé straně.

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

Parametry

str1
A CStringT pro porovnání.

str2
A CStringT pro porovnání.

psz1
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

psz2
Ukazatel na řetězec zakončený hodnotou null pro porovnání.

Poznámky

Lexicographical porovnávání mezi řetězci, znak po znaku až do:

• Najde dva odpovídající znaky, které nejsou stejné a výsledek jejich porovnání je výsledkem porovnání řetězců.

• Nenajde žádné nerovnosti, ale jeden řetězec má více znaků než druhý a kratší řetězec je považován za méně než delší řetězec.

• Nenajde žádné nerovnosti a zjistí, že řetězce mají stejný počet znaků, takže jsou řetězce stejné.

Příklad

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

Určuje, zda je řetězec na levé straně operátoru větší než nebo roven řetězci na pravé straně.

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

Parametry

str1
CStringTPro porovnání.

str2
CStringTPro porovnání.

psz1
Ukazatel na řetězec pro porovnání.

psz2
Ukazatel na řetězec pro porovnání.

Poznámky

Lexicographical porovnávání mezi řetězci, znak po znaku až do:

• Najde dva odpovídající znaky, které nejsou stejné a výsledek jejich porovnání je výsledkem porovnání řetězců.

• Nenajde žádné nerovnosti, ale jeden řetězec má více znaků než druhý a kratší řetězec je považován za méně než delší řetězec.

• Nenajde žádné nerovnosti a zjistí, že řetězce mají stejný počet znaků, takže jsou řetězce stejné.

Příklad

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

Odebere všechny výskyty zadaného znaku z řetězce.

int Remove(XCHAR chRemove);

Parametry

chRemove
Znak, který má být odebrán z řetězce.

Návratová hodnota

Počet znaků odebraných z řetězce. Nula, pokud se řetězec nemění

Poznámky

Porovnávání znaku rozlišuje velká a malá písmena.

Příklad

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

Existují dvě verze systému Replace . První verze nahrazuje jednu nebo více kopií podřetězce pomocí jiného podřetězce. Oba podřetězce jsou zakončené znakem null. Druhá verze nahrazuje jednu nebo více kopií znaku pomocí jiného znaku. Obě verze pracují s daty znaků uloženými v CStringT .

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

Parametry

pszOld
Ukazatel na řetězec zakončený hodnotou null, který má být nahrazen hodnotou pszNew .

pszNew
Ukazatel na řetězec zakončený hodnotou null, který nahrazuje pszOld .

chOld
Znak, který má být nahrazen chNew .

chNew
Nahrazování znaků chOld .

Návratová hodnota

Vrátí počet nahrazených instancí znaku nebo podřetězec nebo hodnotu nula, pokud se řetězec nemění.

Poznámky

Replace může změnit délku řetězce, protože pszNew a nemusí pszOld být stejná délka a několik kopií starého podřetězce lze změnit na nový. Funkce rozlišuje rozlišovat velká a malá písmena.

Příklady CStringT instancí jsou CString , CStringA a CStringW .

Pro CStringAReplace používá sadu ANSI nebo vícebajtových znaků (MBCS). Pro CStringWReplace funguje s velkým množstvím znaků.

Pro CString je typ dat znaků vybrán v době kompilace na základě toho, zda jsou definovány konstanty v následující tabulce.

Příklad

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

Vyhledá CStringT v tomto objektu poslední shodu znaku.

int ReverseFind(XCHAR ch) const throw();

Parametry

ch
Znak, který chcete vyhledat.

Návratová hodnota

Index založený na nule posledního znaku v tomto CStringT objektu, který odpovídá požadovanému znaku, nebo-1, pokud se znak nenajde.

Poznámky

Funkce je podobná funkci run-time strrchr .

Příklad

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

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

CStringT::Right

Extrahuje poslední znaky (to znamená, co je nejvíce vpravo) nCount z tohoto CStringT objektu a vrátí kopii extrahované podřetězce.

CStringT Right(int nCount) const;

Parametry

nCount
Počet znaků, které mají být z tohoto CStringT objektu extrahovány.

Návratová hodnota

CStringTObjekt, který obsahuje kopii zadaného rozsahu znaků. Vrácený CStringT objekt může být prázdný.

Poznámky

Pokud nCount přesahuje délku řetězce, je extrahován celý řetězec. Right se podobá funkci Basic Right (s výjimkou toho, že indexy v Basic jsou počítány od nuly).

U vícebajtových znakových sad ( MBCS ) nCount odkazuje na každý 8bitový znak; to znamená, že vedoucí a koncový bajt v jednom vícebajtovém znaku jsou počítány jako dva znaky.

Příklad

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

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

CStringT::SetSysString

Znovu přidělí BSTR ukazatel, na který odkazuje pbstr , a zkopíruje obsah CStringT objektu do něj, včetně NULL znaku.

BSTR SetSysString(BSTR* pbstr) const;

Parametry

pbstr
Ukazatel na řetězec znaků.

Návratová hodnota

Nový řetězec.

Poznámky

V závislosti na obsahu CStringT objektu se BSTR může změnit hodnota odkazovaného pbstr . Funkce vyvolá výjimku, CMemoryException Pokud existuje nedostatek paměti.

Tato funkce se obvykle používá ke změně hodnoty řetězců předaných odkazem pro automatizaci.

Příklad

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

Extrahuje znaky z řetězce počínaje prvním znakem, který není v sadě znaků identifikovaných pszCharSet .

CStringT SpanExcluding(PCXSTR pszCharSet) const;

Parametry

pszCharSet
Řetězec, který je interpretován jako sada znaků.

Návratová hodnota

Podřetězec obsahující znaky v řetězci, které nejsou v pszCharSet , počínaje prvním znakem v řetězci a končící prvním znakem nalezeným v řetězci, který je také v řetězci pszCharSet (tj. počínaje prvním znakem v řetězci a až s výjimkou prvního znaku v řetězci, který je nalezen pszCharSet ). Vrátí celý řetězec, pokud v řetězci nebyl nalezen žádný znak pszCharSet .

Poznámky

SpanExcluding extrahuje a vrátí všechny znaky před prvním výskytem znaku z pszCharSet (jinými slovy, znak z pszCharSet a všechny znaky, které následují v řetězci, se nevrátí). Pokud pszCharSet v řetězci není nalezen žádný znak, pak SpanExcluding vrátí celý řetězec.

Příklad

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

Extrahuje znaky z řetězce počínaje prvním znakem, které jsou v sadě znaků identifikovaných pszCharSet .

CStringT SpanIncluding(PCXSTR pszCharSet) const;

Parametry

pszCharSet
Řetězec, který je interpretován jako sada znaků.

Návratová hodnota

Podřetězec obsahující znaky v řetězci, které jsou v řetězci, pszCharSet počínaje prvním znakem v řetězci a končí při nalezení znaku v řetězci, který není v pszCharSet . SpanIncluding Vrátí prázdný podřetězec, pokud první znak v řetězci není v zadané sadě.

Poznámky

Pokud první znak řetězce není v sadě znaků, pak SpanIncluding vrátí prázdný řetězec. V opačném případě vrátí posloupnost po sobě jdoucích znaků, které jsou v sadě.

Příklad

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

Vyhledá další token v cílovém řetězci.

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

Parametry

pszTokens
Řetězec obsahující oddělovače tokenů. Pořadí těchto oddělovačů není důležité.

iStart
Index založený na nule pro zahájení hledání.

Návratová hodnota

CStringTObjekt obsahující aktuální hodnotu tokenu.

Poznámky

TokenizeFunkce vyhledá další token v cílovém řetězci. Sada znaků v pszTokens určuje možné oddělovače tokenu, který se má najít. Při každém volání Tokenize funkce se spustí iStart , přeskočí úvodní oddělovače a vrátí CStringT objekt obsahující aktuální token, což je řetězec znaků až k dalšímu znaku oddělovače. Hodnota iStart je aktualizována tak, aby byla pozice za koncovým znakem oddělovače, nebo-1, pokud bylo dosaženo konce řetězce. Další tokeny lze rozdělit ze zbytku cílového řetězce řadou volání na Tokenize , pomocí nástroje iStart pro udržení přehledu o tom, kde v řetězci je další token čten. Pokud nejsou k dispozici žádné další tokeny, funkce vrátí prázdný řetězec a iStart bude nastavena na hodnotu-1.

Na rozdíl od funkce CRT tokenizovat , jako, _strtok_s_l ,, wcstok_s_wcstok_s_l , _mbstok_s_mbstok_s_l , , Tokenize neupravuje cílový řetězec.

Příklad

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

Výstup z tohoto příkladu je následující:

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

CStringT::Trim

Ořízne úvodní a koncové znaky z řetězce.

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

Parametry

chTarget
Cílový znak, který má být oříznut.

pszTargets
Ukazatel na řetězec obsahující cílové znaky, které mají být oříznuty. Všechny úvodní a koncové výskyty znaků v pszTargets se z objektu oříznou CStringT .

Návratová hodnota

Vrátí oříznutý řetězec.

Poznámky

Odebere všechny úvodní a koncové výskyty jednoho z následujících:

• Znak určený parametrem chTarget .

• Všechny znaky nalezené v řetězci určeném parametrem pszTargets .

• Typy.

Příklad

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

Výstup z tohoto příkladu je následující:

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

CStringT::TrimLeft

Ořízne úvodní znaky z řetězce.

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

Parametry

chTarget
Cílový znak, který má být oříznut.

pszTargets
Ukazatel na řetězec obsahující cílové znaky, které mají být oříznuty. Všechny úvodní výskyty znaků v pszTargets se z objektu oříznou CStringT .

Návratová hodnota

Výsledný oříznutý řetězec.

Poznámky

Odebere všechny úvodní a koncové výskyty jednoho z následujících:

• Znak určený parametrem chTarget .

• Všechny znaky nalezené v řetězci určeném parametrem pszTargets .

• Typy.

Příklad

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

Ořízne koncové znaky z řetězce.

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

Parametry

chTarget
Cílový znak, který má být oříznut.

pszTargets
Ukazatel na řetězec obsahující cílové znaky, které mají být oříznuty. Všechny koncové výskyty znaků v pszTargets se z objektu oříznou CStringT .

Návratová hodnota

Vrátí CStringT objekt, který obsahuje oříznutý řetězec.

Poznámky

Odebere koncové výskyty jednoho z následujících:

• Znak určený parametrem chTarget .

• Všechny znaky nalezené v řetězci určeném parametrem pszTargets .

• Typy.

CStringT& TrimRight(XCHAR chTarget)Verze přijímá jeden parametr znaku a odstraní všechny kopie daného znaku z konce CStringT řetězcových dat. Začíná na konci řetězce a funguje směrem dopředu. Zastaví se, když najde jiný znak nebo když CStringT vyčerpá znaková data.

CStringT& TrimRight(PCXSTR pszTargets)Verze přijímá řetězec zakončený hodnotou null, který obsahuje všechny různé znaky, které chcete vyhledat. Odebere všechny kopie těchto znaků v CStringT objektu. Začíná na konci řetězce a funguje směrem dopředu. Zastaví se, když najde znak, který není v cílovém řetězci, nebo při CStringT vyzkoušení znakových dat. Nepokusí se porovnat celý cílový řetězec s podřetězcem na konci CStringT .

CStringT& TrimRight()Verze nevyžaduje žádné parametry. Ořízne všechny koncové prázdné znaky z konce CStringT řetězce. Prázdné znaky mohou být zalomení řádků, mezery nebo tabulátory.

Příklad

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

Viz také

Graf hierarchie
Sdílené třídy ATL/MFC
Deník