CStringT Třída

Tato třída představuje CStringT objekt.

Syntaxe

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

Parametry

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

StringTraits
Určuje, zda třída řetězce potřebuje podporu knihovny C Runtime (CRT) a umístění řetězcových prostředků. Může to být jedna z následujících možností:

• 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

Název	Popis
CStringT::CStringT	CStringT Vytvoří objekt různými způsoby.
CStringT::~CStringT	CStringT Zničí objekt.

Veřejné metody

Název	Popis
CStringT::AllocSysString	Přidělí dataBSTR.CStringT
CStringT::AnsiToOem	Provede místní převod ze znakové sady ANSI na znakovou sadu OEM.
CStringT::AppendFormat	Připojí formátovaná data k existujícímu CStringT objektu.
CStringT::Collate	Porovná dva řetězce (rozlišují se malá a velká písmena, používají informace specifické pro národní prostředí).
CStringT::CollateNoCase	Porovná dva řetězce (nerozlišuje velká a malá písmena, používá informace specifické pro národní prostředí).
CStringT::Compare	Porovná dva řetězce (rozlišují se malá a velká písmena).
CStringT::CompareNoCase	Porovná dva řetězce (nerozlišuje malá a velká písmena).
CStringT::Delete	Odstraní znak nebo znaky z řetězce.
CStringT::Find	Najde znak nebo podřetězce uvnitř většího řetězce.
CStringT::FindOneOf	Najde první odpovídající znak ze sady.
CStringT::Format	Formátuje řetězec stejně jako sprintf vy.
CStringT::FormatMessage	Naformátuje řetězec zprávy.
CStringT::FormatMessageV	Formátuje řetězec zprávy pomocí seznamu argumentů proměnných.
CStringT::FormatV	Formátuje řetězec pomocí seznamu proměnných argumentů.
CStringT::GetEnvironmentVariable	Nastaví řetězec na hodnotu zadané proměnné prostředí.
CStringT::Insert	Vloží jeden znak nebo podřetězce v daném indexu v řetězci.
CStringT::Left	Extrahuje levou část řetězce.
CStringT::LoadString	Načte existující CStringT objekt z prostředku Systému Windows.
CStringT::MakeLower	Převede všechny znaky v tomto řetězci na malá písmena.
CStringT::MakeReverse	Vrátí řetězec.
CStringT::MakeUpper	Převede všechny znaky v tomto řetězci na velká písmena.
CStringT::Mid	Extrahuje střední část řetězce.
CStringT::OemToAnsi	Provede místní převod znakové sady OEM na znakovou sadu ANSI.
CStringT::Remove	Odebere z řetězce označené znaky.
CStringT::Replace	Nahradí označené znaky jinými znaky.
CStringT::ReverseFind	Najde znak uvnitř většího řetězce; začíná od konce.
CStringT::Right	Extrahuje správnou část řetězce.
CStringT::SetSysString	Nastaví existující BSTR objekt s daty z objektu CStringT .
CStringT::SpanExcluding	Extrahuje z řetězce znaky začínající prvním znakem, které nejsou v sadě znaků identifikovaných znakem pszCharSet.
CStringT::SpanIncluding	Extrahuje podřetěr, který obsahuje pouze znaky v sadě.
CStringT::Tokenize	Extrahuje zadané tokeny v cílovém řetězci.
CStringT::Trim	Oříznou všechny počáteční a koncové znaky prázdných znaků z řetězce.
CStringT::TrimLeft	Oříznou počáteční prázdné znaky z řetězce.
CStringT::TrimRight	Oříznou koncové znaky prázdných znaků z řetězce.

Operátory

Název	Popis
CStringT::operator =	Přiřadí objektu novou hodnotu CStringT .
CStringT::operator +	Zřetězí dva řetězce nebo znak a řetězec.
CStringT::operator +=	Zřetězí nový řetězec na konec existujícího řetězce.
CStringT::operator ==	Určuje, jestli jsou dva řetězce logicky rovny.
CStringT::operator !=	Určuje, jestli nejsou dva řetězce logicky rovny.
CStringT::operator <	Určuje, zda je řetězec na levé straně operátoru menší než řetězec na pravé straně.
CStringT::operator >	Určuje, zda je řetězec na levé straně operátoru větší než řetězec na pravé straně.
CStringT::operator <=	Určuje, zda je řetězec na levé straně operátoru menší nebo roven řetězci na pravé straně.
CStringT::operator >=	Určuje, zda je řetězec na levé straně operátoru větší nebo roven řetězci na pravé straně.

Poznámky

CStringT dědí z CSimpleStringT třídy. Pokročilé funkce, jako je manipulace s znaky, řazení a vyhledávání, jsou implementovány CStringT.

Poznámka:

CStringT objekty jsou schopné vyvolat výjimky. K tomu dochází v případě, že objekt CStringT z jakéhokoli důvodu vyčerpá paměť.

Objekt CStringT se skládá z posloupnosti znaků s proměnnou délkou. CStringT poskytuje funkce a operátory používající syntaxi podobnou syntaxi základní. Zřetězení a relační operátory společně se zjednodušenou správou paměti usnadňují CStringT používání objektů než běžná pole znaků.

Poznámka:

I když je možné vytvořit CStringT instance, které obsahují vložené znaky null, doporučujeme, aby byly v něm. Volání metod a operátorů u CStringT objektů, které obsahují vložené znaky null, mohou vést k nezamýšleným výsledkům.

Pomocí různých kombinací BaseType a StringTraits parametrů CStringT mohou objekty pocházet v následujících typech, které byly předdefinovány knihovnami ATL.

Pokud používáte v aplikaci ATL:

CString, CStringAa CStringW jsou exportovány z knihovny MFC DLL (MFC90.DLL), nikdy z uživatelských knihoven DLL. To se provádí, aby se zabránilo CStringT vícenásobnému definování.

Poznámka:

Pokud váš kód obsahuje alternativní řešení pro chyby linkeru popsané v exportu tříd řetězců pomocí CStringT, měli byste tento kód odebrat. Už není zapotřebí.

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

Typ CStringT	Deklarace
CStringA	Řetězec typu znaku ANSI s podporou CRT.
CStringW	Řetězec typu znaku Unicode s podporou CRT.
CString	Typy znaků ANSI i Unicode s podporou CRT.

V projektech, kde ATL_CSTRING_NO_CRT je definováno, jsou k dispozici následující typy řetězců:

Typ CStringT	Deklarace
CAtlStringA	Řetězec typu znak ANSI bez podpory CRT.
CAtlStringW	Řetězec typu znaku Unicode bez podpory CRT.
CAtlString	Typy znaků ANSI i Unicode bez podpory CRT.

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

Typ CStringT	Deklarace
CAtlStringA	Řetězec typu znaku ANSI s podporou CRT.
CAtlStringW	Řetězec typu znaku Unicode s podporou CRT.
CAtlString	Typy znaků ANSI i Unicode s podporou CRT.

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

• CStringT objekty se můžou zvětšovat kvůli operacím zřetězení.

• CStringT objekty se řídí sémantikou hodnot. CStringT Objekt si můžete představit jako skutečný řetězec, ne jako ukazatel na řetězec.

• Argumenty funkce můžete volně nahradit CStringT objekty PCXSTR .

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

Předdefinované typy CStringT

Vzhledem k tomu, že CStringT k definování podporovaného typu znaku (nebo wchar_t char) používá argument šablony, můžou být typy parametrů metody někdy složité. Pro zjednodušení tohoto problému je definována sada předdefinovaných typů a používána CStringT v celé třídě. Následující tabulka uvádí různé typy:

Název	Popis
XCHAR	Jeden znak (nebo wchar_t char) se stejným typem znaku CStringT jako objekt.
YCHAR	Jeden znak (nebo wchar_t char) s opačným typem znaku jako objekt.CStringT
PXSTR	Ukazatel na řetězec znaků (nebo wchar_t char) se stejným typem znaku CStringT jako objekt.
PYSTR	Ukazatel na řetězec znaku (nebo wchar_t char) s opačným typem znaku jako objektem CStringT .
PCXSTR	Ukazatel na const řetězec znaků (nebo wchar_t char) se stejným typem znaku CStringT jako objekt.
PCYSTR	Ukazatel na řetězec znaku (nebo wchar_t char) s opačným const typem znaku jako objektemCStringT.

Poznámka:

Kód, který dříve používal nezdokumentované metody CString (například AssignCopy) musí být nahrazen kódem, který používá následující zdokumentované metody CStringT (například GetBuffer nebo ReleaseBuffer). Tyto metody jsou zděděné z CSimpleStringT.

Hierarchie dědičnosti

CSimpleStringT

CStringT

Požadavky

Hlavička	Použití pro
cstringt.h	Objekty řetězců pouze mfc
atlstr.h	Objekty řetězců jiného typu než MFC

CStringT::AllocSysString

Přidělí řetězec kompatibilní s automatizací typu BSTR a zkopíruje do něj obsah CStringT 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án, CMemoryException pokud existuje dostatek paměti. V aplikacích CAtlException ATL je vyvolán. Tato funkce se obvykle používá k vrácení řetězců pro automatizaci.

Obvykle platí, že pokud je tento řetězec předán funkci COM jako [in] parametr, pak to vyžaduje volající uvolnit řetězec. To lze provést pomocí SysFreeString, jak je popsáno v sadě Windows SDK. Další informace naleznete v tématu Přidělení a uvolnění paměti pro .BSTR

Další informace o funkcích přidělování OLE v systému Windows naleznete SysAllocString v sadě 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í dostupná, pokud _UNICODE je definována.

Příklad

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

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 ovládacího prvku formátu.

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

argument
Volitelné argumenty

Poznámky

Tato funkce formátuje a připojuje řadu znaků a hodnot v objektu CStringT. Každý volitelný argument (pokud existuje) se převede a připojí podle odpovídající specifikace formátu nebo pszFormat z řetězcového prostředku 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í obecné textové funkce _tcscoll.

int Collate(PCXSTR psz) const throw();

Parametry

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

Návratová hodnota

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

Poznámky

Obecná textová funkce _tcscoll, která je definována v TCHAR.H, mapuje na strcoll, wcscollnebo _mbscoll, v závislosti na znakové sadě, která je definována v době kompilace. Každá funkce porovnává řetězce s rozlišováním velkých a malých písmen podle aktuálně používané znakové stránky. Další informace naleznete v tématu strcoll, , _mbscollwcscoll, _strcoll_l, _wcscoll_l_mbscoll_l.

CStringT::CollateNoCase

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

int CollateNoCase(PCXSTR psz) const throw();

Parametry

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

Návratová hodnota

Nulu, pokud jsou řetězce identické (bez ohledu na velká písmena), < 0, pokud je tento CStringT objekt menší než psz (bez rozlišování velkých písmen) nebo > 0, pokud je tento CStringT objekt větší než psz (ignoruje velká písmena).

Poznámky

Obecná textová funkce _tcscoll, která je definována v TCHAR.H, mapuje na stricoll, wcsicollnebo _mbsicoll, v závislosti na znakové sadě, která je definována v době kompilace. Každá funkce nerozlišuje malá a velká písmena řetězců podle aktuálně používané znakové stránky. Další informace naleznete v tématu strcoll, wcscoll, _mbscoll, _strcoll_l, , , , _mbscoll_l. _wcscoll_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šují se malá a velká písmena).

int Compare(PCXSTR psz) const;

Parametry

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

Návratová hodnota

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

Poznámky

Obecná textová funkce _tcscmp, která je definována v TCHAR.H, mapuje na strcmp, wcscmpnebo _mbscmp, v závislosti na znakové sadě, která je definována v době kompilace. Každá funkce porovnává řetězce s rozlišováním velkých a malých písmen a není ovlivněná národním prostředím. Další informace naleznete v tématu strcmp, wcscmp, _mbscmp.

Pokud řetězec obsahuje vložené hodnoty null, pro účely porovnání se řetězec považuje 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 (nerozlišuje malá a velká písmena).

int CompareNoCase(PCXSTR psz) const throw();

Parametry

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

Návratová hodnota

Nulu, pokud jsou řetězce identické (bez ohledu na velká písmena), <0, pokud je tento CStringT objekt menší než psz (bez rozlišování velkých písmen) nebo >0, pokud je tento CStringT objekt větší než psz (ignoruje velká písmena).

Poznámky

Obecná textová funkce _tcsicmp, která je definována v TCHAR.H, mapuje na nebo _wcsicmp _stricmp_mbsicmp, v závislosti na znakové sadě, která je definována v době kompilace. Každá funkce porovnává řetězce bez rozlišování velkých a malých písmen. Porovnání závisí na LC_CTYPE aspektu národního prostředí, ale ne LC_COLLATE. Další informace naleznete v tématu _stricmp, _wcsicmp, _mbsicmp, _stricmp_l, , , , _mbsicmp_l. _wcsicmp_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

CStringT Vytvoří 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 matici znaků délky nLength, nikoli null-terminated.

nLength
Početznakůchch pch

ch
Jeden znak.

pszSrc
Řetězec ukonč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 IAtlStringMgr správě paměti naleznete CStringTv tématu Správa paměti pomocí CStringT.

strSrc
Existující CStringT objekt, který se má do tohoto CStringT objektu zkopírovat. Další informace o CThisString poznámkách a CThisSimpleStringv části Poznámky.

varSrc
Do tohoto CStringT objektu se zkopíruje objekt varianty.

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, jestli je projekt knihovnou MFC DLL (TRUE) nebo ne (FALSE).

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

pString
Popisovač objektu CStringT .

Poznámky

Vzhledem k tomu, že konstruktory kopírují vstupní data do nového přiděleného úložiště, můžou mít za následek výjimky paměti. Některé z těchto konstruktorů fungují jako konverzní funkce. Můžete tak například nahradit, kde LPTSTR CStringT se očekává objekt.

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

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

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

Poznámka:

Definujte makro pro vypnutí implicitního převodu _CSTRING_DISABLE_NARROW_WIDE_CONVERSION řetězců mezi řetězci ANSI a Unicode. Makro vylučuje z konstruktorů kompilace, které podporují převod.

Parametr strSrc může být buď objekt, CStringT nebo CThisSimpleString objekt. Pro CStringTpoužití jedné z výchozích instancí (CString, CStringAnebo CStringW); pro CThisSimpleString, použijte this ukazatel. CThisSimpleString deklaruje instanci CSimpleStringT třídy, což je menší třída řetězce s méně předdefinované funkce než CStringT třída.

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

Poznámka:

I když je možné vytvořit CStringT instance, které obsahují vložené znaky null, doporučujeme, aby byly v něm. Volání metod a operátorů u CStringT objektů, které obsahují vložené znaky null, mohou vést k nezamýšleným výsledkům.

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

CStringT Zničí objekt.

~CStringT() throw();

Poznámky

CStringT Zničí objekt.

CStringT::Delete

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

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

Parametry

iIndex
Index založený na nule prvního znaku v objektu CStringT , který chcete odstranit.

nCount
Počet znaků, které se mají odebrat.

Návratová hodnota

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

Poznámky

Pokud nCount je řetězec delší, 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á tento řetězec pro 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ětěr, který chcete vyhledat.

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

ch
Jeden znak, který chcete vyhledat.

Návratová hodnota

Index založený na nule prvního znaku v tomto CStringT objektu, který odpovídá požadovanému podřetědci nebo znaky; -1, pokud nebyl nalezen podřetětěr nebo znak.

Poznámky

Funkce je přetížena tak, aby přijímala oba jednotlivé znaky (podobně jako funkce strchrza běhu) a řetězce (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á tento řetězec pro první znak, který odpovídá jakémukoli 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 založený na nule prvního znaku v tomto řetězci, který je také v pszCharSet; -1, pokud neexistuje shoda.

Poznámky

Najde první výskyt libovolného 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 CStringT stejným způsobem jako sprintf_s data do pole znaků 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 ovládací prvek formátu.

pszFormat
Řetězec ovládacího prvku formátu.

argument
Volitelné argumenty

Poznámky

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

Volání selže, pokud samotný objekt řetězce je 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 naleznete v tématu Syntaxe specifikace formátu: printf 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

Naformá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 řetězec ovládacího prvku formátu. Naskenuje se vložení a odpovídajícím způsobem naformátuje. Formátovací řetězec je podobný řetězci formátu run-time funkce printf-style formátovací řetězce, s výjimkou toho, že umožňuje, aby parametry byly vloženy do libovolného pořadí.

argument
Volitelné argumenty

Poznámky

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

Poznámka:

FormatMessage se pokusí přidělit systémovou paměť pro nově formátovaný řetězec. Pokud tento pokus selže, automaticky se vyvolá výjimka paměti.

Každé vložení musí mít odpovídající parametr za parametrem nebo nFormatID parametrempszFormat. V textu zprávy je podporováno několik řídicích sekvencí pro dynamické formátování zprávy. Další informace najdete ve funkci Windows FormatMessage v sadě 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 ovládacího prvku formátu. Naskenuje se vložení a odpovídajícím způsobem naformátuje. Formátovací řetězec je podobný řetězci formátu run-time funkce printf-style formátovací řetězce, s výjimkou toho, že umožňuje, aby parametry byly vloženy do libovolného pořadí.

pArgList
Ukazatel na seznam argumentů

Poznámky

Funkce vyžaduje definici zprávy jako vstup určený .pszFormat Funkce zkopíruje formátovaný text zprávy a seznam proměnných argumentů do objektu CStringT a v případě potřeby zpracuje všechny vložené sekvence vložení.

Poznámka:

FormatMessageV volání CStringT::FormatMessage, která se pokusí přidělit systémovou paměť pro nově formátovaný řetězec. Pokud tento pokus selže, automaticky se vyvolá výjimka paměti.

Další informace najdete ve funkci Windows FormatMessage v sadě 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 ovládacího prvku formátu. Naskenuje se vložení a odpovídajícím způsobem naformátuje. Formátovací řetězec je podobný řetězci formátu run-time funkce printf-style formátovací řetězce, s výjimkou toho, že umožňuje, aby parametry byly vloženy do libovolného 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, jakým 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 ukončený hodnotou null, který určuje proměnnou prostředí.

Návratová hodnota

Nenulové, pokud je úspěšné; jinak 0.

Poznámky

Načte hodnotu zadané proměnné z bloku prostředí volajícího procesu. Hodnota je ve formě řetězce znaků ukonč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ězce v daném indexu v řetězci.

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

Parametry

iIndex
Index znaku, před kterým bude vloženo.

psz
Ukazatel na podřetěžce, který se má vložit.

ch
Znak, který se má vložit.

Návratová hodnota

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

Poznámky

Parametr iIndex identifikuje první znak, který se přesune, aby byl prostor pro znak nebo podřetěžek. Pokud nIndex je nula, vložení proběhne před celým řetězcem. Pokud je hodnota nIndex vyšší než délka řetězce, funkce zřetědí aktuální řetězec a nový materiál poskytnutý buď ch 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 z tohoto CStringT objektu úplně nCount vlevo znaky a vrátí kopii extrahovaného podřetědce.

CStringT Left(int nCount) const;

Parametry

nCount
Počet znaků, které se mají extrahovat z tohoto CStringT objektu.

Návratová hodnota

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

Poznámky

Pokud nCount překročí délku řetězce, celý řetězec se extrahuje. Left je podobný funkci Basic Left .

U vícebajtových znakových sad (MBCS) nCount považuje každou 8bitovou sekvenci za znak, takže nCount vrátí počet vícebajtových znaků vynásobených dvěma znaky.

Příklad

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

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

CStringT::LoadString

Načte prostředek řetězce systému Windows identifikovaný pomocí nID do existujícího CStringT 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 řetězce Systému Windows.

wLanguageID
Jazyk prostředku řetězce.

Návratová hodnota

Nenulové, pokud bylo zatížení prostředků úspěšné; jinak 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 objekt na řetězec malými písmeny CStringT .

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 objektu CStringT .

CStringT& MakeReverse();

Návratová hodnota

Výsledný obrácený ř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 objekt na řetězec velkými písmeny CStringT .

CStringT& MakeUpper();

Návratová hodnota

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

Poznámky

Příklad

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

CAtlString s(_T("abc"));

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

CStringT::Mid

Extrahuje z tohoto CStringT objektu podřetězdí znaky délkynCount, počínaje pozicí iFirst (založenou na nule).

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ého podřetětědce.

nCount
Počet znaků, které se mají extrahovat z tohoto CStringT objektu. Pokud tento parametr není zadaný, zbytek řetězce se extrahuje.

Návratová hodnota

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

Poznámky

Funkce vrátí kopii extrahovaného podřetědce. Mid je podobná funkci Basic Mid (s tím rozdílem, že indexy v basicu jsou založené na jednom).

U vícebajtových znakových sad (MBCS) nCount odkazuje na každý 8bitový znak. To znamená, že hlavní a koncový bajt v jednom vícebajtovém znaku se počítají 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í dostupná, pokud _UNICODE 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
A CStringT pro 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
Objekt varianty, který se má přiřadit k tomuto řetězci.

ch
Znak ANSI nebo Unicode, který se má přiřadit 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 znaku nebo jeden znak. K výjimkám 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 CThisSimpleString, viz poznámky oddílu CStringT::CStringT.

Poznámka:

I když je možné vytvořit CStringT instance, které obsahují vložené znaky null, doporučujeme, aby byly v něm. Volání metod a operátorů u CStringT objektů, které obsahují vložené znaky null, mohou vést k nezamýšleným výsledkům.

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, který se má zřetězením s řetězcem.

ch2
Znak ANSI nebo Unicode, který se má zřetězením s řetězcem.

str1
A CStringT pro zřetězení s řetězcem nebo znakem.

str2
A CStringT pro zřetězení s řetězcem nebo znakem.

psz1
Ukazatel na řetězec ukončený hodnotou null pro zřetězení s řetězcem nebo znakem.

psz2
Ukazatel na řetězec ke zřetězení s řetězcem nebo znakem.

Poznámky

Existuje sedm forem CStringT::operator+ přetížení funkce. První verze zřetězí dva existující CStringT objekty. Další dva zřetězení objektu CStringT a řetězce s ukončenou hodnotou null. Další dva zřetězení objektu CStringT a znak ANSI. Poslední dva zřetězení objektu CStringT a znaku Unicode.

Poznámka:

I když je možné vytvořit CStringT instance, které obsahují vložené znaky null, doporučujeme, aby byly v něm. Volání metod a operátorů u CStringT objektů, které obsahují vložené znaky null, mohou vést k nezamýšleným výsledkům.

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
Objekt varianty, který se má zřetězením tohoto řetězce.

ch
Znak ANSI nebo Unicode, který se má zřetězením s řetězcem.

pszSrc
Ukazatel na původní řetězec, který je zřetězený.

strSrc
A CStringT pro zřetězení s tímto řetězcem.

Poznámky

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

Informace o CThisSimpleString, viz poznámky oddílu CStringT::CStringT.

Poznámka:

I když je možné vytvořit CStringT instance, které obsahují vložené znaky null, doporučujeme, aby byly v něm. Volání metod a operátorů u CStringT objektů, které obsahují vložené znaky null, mohou vést k nezamýšleným výsledkům.

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

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 ukončený hodnotou null pro porovnání.

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

Poznámky

Testuje, zda je řetězec nebo znak na levé straně roven ř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, který se má zřetězením s řetězcem.

ch2
Znak ANSI nebo Unicode, který se má zřetězením s řetězcem.

str1
A CStringT pro porovnání.

str2
A CStringT pro porovnání.

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

psz2
Ukazatel na řetězec ukonč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 ukončený hodnotou null pro porovnání.

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

Poznámky

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

• Najde dva odpovídající znaky nerovné a výsledek jejich porovnání se bere 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 se považuje za menší než delší řetězec.

• Nenajde žádné nerovnosti a zjistí, že řetězce mají stejný počet znaků, a proto 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("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 ukončený hodnotou null pro porovnání.

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

Poznámky

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

• Najde dva odpovídající znaky nerovné a výsledek jejich porovnání se bere 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 se považuje za menší než delší řetězec.

• Nenajde žádné nerovnosti a zjistí, že řetězce mají stejný počet znaků, takže řetězce jsou 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") > 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 ukončený hodnotou null pro porovnání.

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

Poznámky

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

• Najde dva odpovídající znaky nerovné a výsledek jejich porovnání se bere 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 se považuje za menší než delší řetězec.

• Nenajde žádné nerovnosti a zjistí, že řetězce mají stejný počet znaků, takže řetězce jsou 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ší 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 pro porovnání.

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

Poznámky

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

• Najde dva odpovídající znaky nerovné a výsledek jejich porovnání se bere 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 se považuje za menší než delší řetězec.

• Nenajde žádné nerovnosti a zjistí, že řetězce mají stejný počet znaků, takže řetězce jsou 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 instance zadaného znaku z řetězce.

int Remove(XCHAR chRemove);

Parametry

chRemove
Znak, který se má odebrat z řetězce.

Návratová hodnota

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

Poznámky

Porovnání znaku rozlišují malá a velká 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 Replace. První verze nahradí jednu nebo více kopií podřetězece jiným podřetězecem. Oba podřetězené řetězce jsou ukončeny hodnotou null. Druhá verze nahradí jednu nebo více kopií znaku jiným znakem. 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 ukončený hodnotou null, který pszNewse má nahradit .

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

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

chNew
Znak nahrazení chOld.

Návratová hodnota

Vrátí počet nahrazených instancí znaku nebo podřetězce nebo nuly, pokud se řetězec nezmění.

Poznámky

Replace může změnit délku řetězce, protože pszNew nemusí pszOld mít stejnou délku a několik kopií starého podřetězce lze změnit na nový. Funkce porovnává malá a velká písmena.

CStringT Příklady instancí jsou CString, CStringAa CStringW.

Pro CStringApráci Replace se znaky ANSI nebo vícebajtovými znaky (MBCS). Pro CStringW, Replace funguje s širokými znaky.

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

Definovaná konstanta	Datový typ znaku
_UNICODE	Široké znaky
_MBCS	Vícebajtů znaků
Ani jedno	Jednobajtů znaků
Oba	Nedefinováno

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á tento CStringT objekt 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 znak nebyl nalezen.

Poznámky

Funkce je podobná funkci strrchrza běhu .

Příklad

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

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

CStringT::Right

Extrahuje z tohoto CStringT objektu poslední znaky (tj. úplně vpravo) nCount a vrátí kopii extrahovaného podřetětěce.

CStringT Right(int nCount) const;

Parametry

nCount
Počet znaků, které se mají extrahovat z tohoto CStringT objektu.

Návratová hodnota

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

Poznámky

Pokud nCount překročí délku řetězce, celý řetězec se extrahuje. Right je podobný funkci Basic Right (s tím rozdílem, že indexy v jazyce Basic jsou založené na nule).

U vícebajtových znakových sad (MBCS), nCount odkazuje na každý 8bitový znak. To znamená, že hlavní a koncový bajt v jednom vícebajtovém znaku se počítají 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

Přeloží BSTR odkaz na objekt pbstr a zkopíruje do něj obsah CStringT objektu, včetně znaku NULL .

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 objektu CStringT se může změnit hodnota BSTR odkazovaného objektu pbstr . Funkce vyvolá CMemoryException chybu, pokud není k dispozici dostatek paměti.

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

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 z řetězce znaky začínající prvním znakem, které nejsou v sadě znaků identifikovaných znakem pszCharSet.

CStringT SpanExcluding(PCXSTR pszCharSet) const;

Parametry

pszCharSet
Řetězec interpretovaný jako sada znaků.

Návratová hodnota

Podřetězce obsahující znaky v řetězci, které nejsou v pszCharSetřetězci , počínaje prvním znakem v řetězci a končícím prvním znakem nalezeným v řetězci pszCharSet (to znamená, že začíná prvním znakem v řetězci a až po vyloučení prvního znaku v řetězci, který je nalezen pszCharSet). Vrátí celý řetězec, pokud se v řetězci nenajde žádný znak pszCharSet .

Poznámky

SpanExcluding extrahuje a vrátí všechny znaky předcházející prvnímu výskytu znaku z pszCharSet (jinými slovy, znak od a všechny znaky, které pszCharSet následují v řetězci, se nevrátí). Pokud se v řetězci nenajde žádný znak pszCharSet , 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("abcdef"));

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

CStringT::SpanIncluding

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

CStringT SpanIncluding(PCXSTR pszCharSet) const;

Parametry

pszCharSet
Řetězec interpretovaný jako sada znaků.

Návratová hodnota

Podřetězce obsahující znaky v řetězci, který je v pszCharSetřetězci , počínaje prvním znakem v řetězci a končícím znakem v řetězci, který není v pszCharSet. SpanIncluding vrátí prázdný podřetězc, pokud první znak v řetězci není v zadané sadě.

Poznámky

Pokud první znak řetězce není ve znakové sadě, 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

Najde 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, který zahájí hledání.

Návratová hodnota

Objekt CStringT obsahující aktuální hodnotu tokenu.

Poznámky

Funkce Tokenize najde v cílovém řetězci další token. Sada znaků určuje pszTokens možné oddělovače tokenu, které se mají najít. Při každém volání Tokenize funkce začíná na iStart, přeskočí počáteční oddělovače a vrátí CStringT objekt obsahující aktuální token, což je řetězec znaků až do další znak oddělovače. Hodnota iStart je aktualizována tak, aby byla pozice za koncovým znakem oddělovače nebo -1, pokud byl dosažen konec řetězce. Další tokeny je možné rozdělit ze zbytku cílového řetězce pomocí řady volání Tokenize, pomocí iStart které chcete sledovat, kde v řetězci se má další token číst. Pokud už tokeny neexistují, funkce vrátí prázdný řetězec a iStart nastaví se na hodnotu -1.

Na rozdíl od funkcí tokenizace CRT, jako je , _mbstok_s_strtok_s_lTokenize wcstok_s_mbstok_s_l_wcstok_s_lneupravuje cílový řetězec.strtok_s

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říznou počáteční a koncové znaky z řetězce.

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

Parametry

chTarget
Cílový znak, který se má oříznout.

pszTargets
Ukazatel na řetězec obsahující cílové znaky, které se mají oříznout. Všechny počáteční a koncové výskyty znaků se pszTargets z objektu CStringT oříznou.

Návratová hodnota

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

Poznámky

Odebere všechny počáteční a koncové výskyty jednoho z následujících:

• Znak určený znakem chTarget.

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

• Prázdné místo.

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říznou počáteční znaky z řetězce.

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

Parametry

chTarget
Cílový znak, který se má oříznout.

pszTargets
Ukazatel na řetězec obsahující cílové znaky, které se mají oříznout. Všechny počáteční výskyty znaků v pszTargets objektu CStringT budou oříznuty.

Návratová hodnota

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

Poznámky

Odebere všechny počáteční a koncové výskyty jednoho z následujících:

• Znak určený znakem chTarget.

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

• Prázdné místo.

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říznou koncové znaky z řetězce.

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

Parametry

chTarget
Cílový znak, který se má oříznout.

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

Návratová hodnota

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

Poznámky

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

• Znak určený znakem chTarget.

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

• Prázdné místo.

Verze CStringT& TrimRight(XCHAR chTarget) přijímá jeden znakový parametr a odebere všechny kopie tohoto znaku na konci řetězcových CStringT dat. Začíná od konce řetězce a pracuje směrem k přední části. Zastaví se, když najde jiný znak nebo když CStringT dojde k vyčerpání dat znaků.

Verze CStringT& TrimRight(PCXSTR pszTargets) přijímá řetězec ukončený hodnotou null, který obsahuje všechny různé znaky, které chcete vyhledat. Odebere všechny kopie těchto znaků v objektu CStringT . Začíná na konci řetězce a pracuje směrem k přední části. Zastaví se, když najde znak, který není v cílovém řetězci nebo když CStringT vyčerpá data znaků. Nepokouší se shodovat celý cílový řetězec s podřetězcem na konci CStringT.

Verze CStringT& TrimRight() nevyžaduje žádné parametry. Ořízne všechny koncové prázdné znaky od konce CStringT řetězce. Prázdné znaky můžou být konce řá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
CSimpleStringT Třída