`CSimpleStringT` Třída

Článek
04/11/2024

Tato třída představuje CSimpleStringT objekt.

Syntaxe

template <typename BaseType>
class CSimpleStringT

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

Členové

Veřejné definice typedef

Název	Popis
`CSimpleStringT::PCXSTR`	Ukazatel na konstantní řetězec.
`CSimpleStringT::PXSTR`	Ukazatel na řetězec.

Veřejné konstruktory

Název	Popis
`CSimpleStringT::CSimpleStringT`	Vytváří objekty `CSimpleStringT` různými způsoby.
`CSimpleStringT::~CSimpleStringT`	Destruktor.

Veřejné metody

Název	Popis
`CSimpleStringT::Append`	`CSimpleStringT` Připojí objekt k existujícímu `CSimpleStringT` objektu.
`CSimpleStringT::AppendChar`	Připojí znak k existujícímu `CSimpleStringT` objektu.
`CSimpleStringT::CopyChars`	Zkopíruje znak nebo znaky do jiného řetězce.
`CSimpleStringT::CopyCharsOverlapped`	Zkopíruje znak nebo znaky do jiného řetězce, ve kterém se vyrovnávací paměti překrývají.
`CSimpleStringT::Empty`	Vynutí řetězec, aby měl délku nuly.
`CSimpleStringT::FreeExtra`	Uvolní veškerou dodatečnou paměť dříve přidělenou objektem řetězce.
`CSimpleStringT::GetAllocLength`	Načte přidělenou délku objektu `CSimpleStringT` .
`CSimpleStringT::GetAt`	Vrátí znak na dané pozici.
`CSimpleStringT::GetBuffer`	Vrátí ukazatel na znaky v znaku `CSimpleStringT`.
`CSimpleStringT::GetBufferSetLength`	Vrátí ukazatel na znaky v `CSimpleStringT`znaky zkrácené na zadanou délku.
`CSimpleStringT::GetLength`	Vrátí počet znaků v objektu `CSimpleStringT` .
`CSimpleStringT::GetManager`	Načte správce paměti objektu `CSimpleStringT` .
`CSimpleStringT::GetString`	Načte řetězec znaků.
`CSimpleStringT::IsEmpty`	Testuje, zda `CSimpleStringT` objekt neobsahuje žádné znaky.
`CSimpleStringT::LockBuffer`	Zakáže počítání odkazů a chrání řetězec v vyrovnávací paměti.
`CSimpleStringT::Preallocate`	Přidělí určitou velikost paměti pro vyrovnávací paměť znaků.
`CSimpleStringT::ReleaseBuffer`	Uvolní kontrolu vyrovnávací paměti vrácené `GetBuffer`.
`CSimpleStringT::ReleaseBufferSetLength`	Uvolní kontrolu vyrovnávací paměti vrácené `GetBuffer`.
`CSimpleStringT::SetAt`	Nastaví znak na dané pozici.
`CSimpleStringT::SetManager`	Nastaví správce paměti objektu `CSimpleStringT` .
`CSimpleStringT::SetString`	Nastaví řetězec objektu `CSimpleStringT` .
`CSimpleStringT::StringLength`	Vrátí počet znaků v zadaném řetězci.
`CSimpleStringT::Truncate`	Zkrátí řetězec na zadanou délku.
`CSimpleStringT::UnlockBuffer`	Povolí počítání odkazů a uvolní řetězec v vyrovnávací paměti.

Veřejné operátory

Název	Popis
`CSimpleStringT::operator PCXSTR`	Přímo přistupuje ke znakům uloženým v objektu `CSimpleStringT` jako řetězec ve stylu jazyka C.
`CSimpleStringT::operator[]`	Vrátí znak na dané pozici – nahrazení operátoru `GetAt`.
`CSimpleStringT::operator +=`	Zřetězí nový řetězec na konec existujícího řetězce.
`CSimpleStringT::operator =`	Přiřadí objektu novou hodnotu `CSimpleStringT` .

Poznámky

CSimpleStringT je základní třída pro různé třídy řetězců podporované jazykem Visual C++. Poskytuje minimální podporu pro správu paměti objektu řetězce a základní manipulaci s vyrovnávací pamětí. Pokročilejší řetězcové objekty naleznete v tématu CStringT Class.

Požadavky

Záhlaví: atlsimpstr.h

`CSimpleStringT::Append`

CSimpleStringT Připojí objekt k existujícímu CSimpleStringT objektu.

Syntaxe

void Append(const CSimpleStringT& strSrc);
void Append(PCXSTR pszSrc, int nLength);
void Append(PCXSTR pszSrc);

Parametry

strSrc
Objekt CSimpleStringT , který se má připojit.

pszSrc
Ukazatel na řetězec obsahující znaky, které se mají připojit.

nLength
Počet znaků, které se mají připojit.

Poznámky

Voláním této metody připojíte existující CSimpleStringT objekt k jinému CSimpleStringT objektu.

Příklad

Následující příklad ukazuje použití CSimpleStringT::Append.

CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str1(pMgr), str2(pMgr);
str1.SetString(_T("Soccer is"));
str2.SetString(_T(" an elegant game"));
str1.Append(str2);
ASSERT(_tcscmp(str1, _T("Soccer is an elegant game")) == 0);

`CSimpleStringT::AppendChar`

Připojí znak k existujícímu CSimpleStringT objektu.

Syntaxe

void AppendChar(XCHAR ch);

Parametry

ch
Znak, který se má připojit

Poznámky

Voláním této funkce připojíte zadaný znak na konec existujícího CSimpleStringT objektu.

`CSimpleStringT::CopyChars`

Zkopíruje znak nebo znaky do objektu CSimpleStringT .

Syntaxe

static void CopyChars(
    XCHAR* pchDest,
    const XCHAR* pchSrc,
    int nChars) throw();
static void CopyChars(
    XCHAR* pchDest,
    size_t nDestLen,
    const XCHAR* pchSrc,
    int nChars) throw();

Parametry

pchDest
Ukazatel na řetězec znaků.

nDestLen
Velikost vyrovnávací paměti pchDest

pchSrc
Ukazatel na řetězec obsahující znaky, které se mají zkopírovat.

nChars
Počet pchSrc znaků, které se mají zkopírovat.

Poznámky

Voláním této metody zkopírujte znaky z pchSrc pchDest řetězce.

Příklad

Následující příklad ukazuje použití CSimpleStringT::CopyChars.

CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str(_T("xxxxxxxxxxxxxxxxxxx"), 20, pMgr);
const TCHAR* pszSrc = _T("Hello world!");
_tprintf_s(_T("%s\n"), str);
str.CopyChars(str.GetBuffer(), 20, pszSrc, 12);
_tprintf_s(_T("%s\n"), str);

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

xxxxxxxxxxxxxxxxxxx
Hello world!xxxxxxx

`CSimpleStringT::CopyCharsOverlapped`

Zkopíruje znak nebo znaky do objektu CSimpleStringT .

Syntaxe

static void CopyCharsOverlapped(
    XCHAR* pchDest,
    const XCHAR* pchSrc,
    int nChars) throw();

Parametry

pchDest
Ukazatel na řetězec znaků.

pchSrc
Ukazatel na řetězec obsahující znaky, které se mají zkopírovat.

nChars
Počet pchSrc znaků, které se mají zkopírovat.

Poznámky

Voláním této metody zkopírujte znaky z pchSrc pchDest řetězce. Na rozdíl od CopyChars, CopyCharsOverlapped poskytuje bezpečnou metodu pro kopírování z vyrovnávací paměti znaků, které se mohou překrývat.

Příklad

Podívejte se na příklad nebo CSimpleStringT::CopyCharszdrojový kód pro CSimpleStringT::SetString (umístěný v atlsimpstr.h).

`CSimpleStringT::CSimpleStringT`

CSimpleStringT Vytvoří objekt.

Syntaxe

CSimpleStringT(const XCHAR* pchSrc, int nLength, IAtlStringMgr* pStringMgr);
CSimpleStringT(PCXSTR pszSrc, IAtlStringMgr* pStringMgr);
CSimpleStringT(const CSimpleStringT& strSrc);
explicit CSimpleStringT(IAtlStringMgr* pStringMgr) throw();

Parametry

strSrc
Existující CSimpleStringT objekt, který se má do tohoto CSimpleStringT objektu zkopírovat.

pchSrc
Ukazatel na pole znaků délky nLength, není ukončena null.

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

nLength
Početznakůchch pch

pStringMgr
Ukazatel na správce paměti objektu CSimpleStringT . Další informace o správě paměti naleznete IAtlStringMgr CSimpleStringTv tématu Správa paměti a CStringT.

Poznámky

Vytvořte nový CSimpleStringT objekt. 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.

Příklad

Následující příklad ukazuje použití CSimpleStringT::CSimpleStringT pomocí ATL typedef CSimpleString. CSimpleString je běžně používaná specializace šablony CSimpleStringTtřídy .

CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();

CSimpleString s1(pMgr);
// Empty string
CSimpleString s2(_T("cat"), pMgr);
// From a C string literal

CSimpleString s3(s2);
// Copy constructor
CSimpleString s4(s2 + _T(" ") + s3);

// From a string expression
CSimpleString s5(_T("xxxxxx"), 6, pMgr);
// s5 = "xxxxxx"

`CSimpleStringT::Empty`

Vytvoří tento CSimpleStringT objekt prázdný řetězec a podle potřeby uvolní paměť.

Syntaxe

void Empty() throw();

Poznámky

Další informace naleznete v tématu Řetězce: CString Vyčištění výjimky.

Příklad

Následující příklad ukazuje použití CSimpleStringT::Empty.

CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();

CSimpleString s(pMgr);
ASSERT(s.IsEmpty());

`CSimpleStringT::FreeExtra`

Uvolní veškerou dodatečnou paměť, kterou dříve přidělil řetězec, ale už ji nepotřebujete.

Syntaxe

void FreeExtra();

Poznámky

Tím by se měly snížit režijní náklady na paměť spotřebované objektem řetězce. Metoda relokuje vyrovnávací paměť na přesnou délku vrácenou GetLength.

Příklad

CAtlString basestr;
IAtlStringMgr* pMgr;

pMgr= basestr.GetManager();
ASSERT(pMgr != NULL);

// Create a CSimpleString with 28 characters
CSimpleString str(_T("Many sports are fun to play."), 28, pMgr);
_tprintf_s(_T("Alloc length is %d, String length is %d\n"),
   str.GetAllocLength(), str.GetLength());

// Assigning a smaller string won't cause CSimpleString to free its
// memory, because it assumes the string will grow again anyway.
str = _T("Soccer is best!");
_tprintf_s(_T("Alloc length is %d, String length is %d\n"),
   str.GetAllocLength(), str.GetLength());

// This call forces CSimpleString to release the extra
// memory it doesn't need.
str.FreeExtra();
_tprintf_s(_T("Alloc length is %d, String length is %d\n"),
   str.GetAllocLength(), str.GetLength());

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

Alloc length is 1031, String length is 1024
Alloc length is 1031, String length is 15
Alloc length is 15, String length is 15

`CSimpleStringT::GetAllocLength`

Načte přidělenou délku objektu CSimpleStringT .

Syntaxe

int GetAllocLength() const throw();

Návratová hodnota

Počet znaků přidělených pro tento objekt.

Poznámky

Voláním této metody určíte počet znaků přidělených pro tento CSimpleStringT objekt. Podívejte se FreeExtra na příklad volání této funkce.

`CSimpleStringT::GetAt`

Vrátí jeden znak z objektu CSimpleStringT .

Syntaxe

XCHAR GetAt(int iChar) const;

Parametry

iChar
Index znaku v objektu CSimpleStringT založený na nule. Parametr iChar musí být větší nebo roven 0 a menší než hodnota vrácená GetLengthhodnotou . GetAt V opačném případě vygeneruje výjimku.

Návratová hodnota

Znak XCHAR , který obsahuje znak na zadané pozici v řetězci.

Poznámky

Voláním této metody vrátíte jeden znak určený iChar. Přetížený operátor dolního indexu ([]) je pohodlný alias pro GetAt. Ukončovací znak null je adresovatelný bez vygenerování výjimky pomocí GetAt. Není však počítáno GetLengthhodnotou a vrácená hodnota je 0.

Příklad

Následující příklad ukazuje, jak použít CSimpleStringT::GetAt.

CSimpleString s(_T("abcdef"), pMgr);
ASSERT(s.GetAt(2) == _T('c'));

`CSimpleStringT::GetBuffer`

Vrátí ukazatel na interní vyrovnávací paměť znaků objektu CSimpleStringT .

Syntaxe

PXSTR GetBuffer(int nMinBufferLength);
PXSTR GetBuffer();

Parametry

nMinBufferLength
Minimální početznakůch Tato hodnota neobsahuje mezeru pro ukončovací znak null.

Pokud nMinBufferLength je větší než délka aktuální vyrovnávací paměti, GetBuffer zničí aktuální vyrovnávací paměť, nahradí ji vyrovnávací pamětí požadované velikosti a resetuje počet odkazů na objekt na nulu. Pokud jste dříve volali LockBuffer tuto vyrovnávací paměť, ztratíte zámek vyrovnávací paměti.

Návratová hodnota

PXSTR Ukazatel na vyrovnávací paměť znaku objektu (ukončený hodnotou null).

Poznámky

Voláním této metody vrátí obsah vyrovnávací paměti objektu CSimpleStringT . Vrácená PXSTR hodnota není konstanta, a proto umožňuje přímou úpravu CSimpleStringT obsahu.

Pokud použijete ukazatel vrácený GetBuffer ke změně obsahu řetězce, musíte volat ReleaseBuffer aktualizaci interního CSimpleStringT stavu dříve, než použijete jiné CSimpleStringT metody.

Adresa vrácená GetBuffer voláním ReleaseBuffer nemusí být platná, protože další CSimpleStringT operace mohou způsobit CSimpleStringT , že vyrovnávací paměť bude relokována. Vyrovnávací paměť není relokována, pokud nezměníte délku CSimpleStringT.

Paměť vyrovnávací paměti se automaticky uvolní při zničení objektu CSimpleStringT .

Pokud budete mít přehled o délce řetězce sami, neměli byste přidávat ukončující znak null. Je však nutné zadat konečnou délku řetězce při uvolnění vyrovnávací paměti s ReleaseBuffer. Pokud připojíte ukončující znak null, měli byste pro délku předat hodnotu -1 (výchozí). ReleaseBuffer pak určuje délku vyrovnávací paměti.

Pokud není dostatek paměti pro splnění GetBuffer požadavku, tato metoda vyvolá CMemoryException*chybu .

Příklad

CSimpleString s(_T("abcd"), pMgr);
LPTSTR pBuffer = s.GetBuffer(10);
int sizeOfBuffer = s.GetAllocLength();

// Directly access CSimpleString buffer
_tcscpy_s(pBuffer, sizeOfBuffer, _T("Hello"));
ASSERT(_tcscmp(s, _T("Hello")) == 0);
s.ReleaseBuffer();

`CSimpleStringT::GetBufferSetLength`

Vrátí ukazatel na vnitřní vyrovnávací paměť znaků objektu CSimpleStringT , zkrácení nebo zvětšení jeho délky v případě potřeby přesně odpovídat délce zadané v nLength.

Syntaxe

PXSTR GetBufferSetLength(int nLength);

Parametry

nLength
Přesná velikost CSimpleStringT vyrovnávací paměti znaků ve znaznach.

Návratová hodnota

PXSTR Ukazatel na vyrovnávací paměť znaku objektu (ukončený hodnotou null).

Poznámky

Voláním této metody načtěte zadanou délku vnitřní vyrovnávací paměti objektu CSimpleStringT . Vrácený PXSTR ukazatel není const a umožňuje tak přímou úpravu CSimpleStringT obsahu.

Pokud použijete ukazatel vrácený GetBufferSetLength ke změně obsahu řetězce, volání ReleaseBuffer aktualizace interního CSimpleStringT stavu před použitím jiných CSimpleStringT metod.

Adresa vrácená GetBufferSetLength voláním ReleaseBuffer nemusí být platná, protože další CSimpleStringT operace mohou způsobit CSimpleStringT , že vyrovnávací paměť bude relokována. Vyrovnávací paměť není znovu přiřazena, pokud nezměníte délku CSimpleStringT.

Paměť vyrovnávací paměti se automaticky uvolní při zničení objektu CSimpleStringT .

Pokud budete mít přehled o délce řetězce sami, nepřidávejte ukončující znak null. Při uvolnění vyrovnávací paměti pomocí ReleaseBufferje nutné zadat konečnou délku řetězce . Pokud při volání ReleaseBufferpřipojíte ukončující znak null , předejte hodnotu -1 (výchozí) pro délku ReleaseBuffera ReleaseBuffer provedete strlen s vyrovnávací pamětí hodnotu, která určí jeho délku.

Další informace o počítání odkazů najdete v následujících článcích:

Správa životností objektů prostřednictvím počítání odkazů v sadě Windows SDK
Implementace počítání odkazů v sadě Windows SDK
Pravidla pro správu počtu odkazů v sadě Windows SDK

Příklad

Následující příklad ukazuje použití CSimpleStringT::GetBufferSetLength.

CSimpleString str(pMgr);
LPTSTR pstr = str.GetBufferSetLength(3);
pstr[0] = _T('C');
pstr[1] = _T('u');
pstr[2] = _T('p');
str.ReleaseBuffer();

str += _T(" soccer is best!");
ASSERT(_tcscmp(str, _T("Cup soccer is best!")) == 0);

`CSimpleStringT::GetLength`

Vrátí počet znaků v objektu CSimpleStringT .

Syntaxe

int GetLength() const throw();

Návratová hodnota

Počet znaků v řetězci.

Poznámky

Voláním této metody vrátíte počet znaků v objektu. Počet neobsahuje ukončovací znak null.

U vícebajtových znakových sad (MBCS) GetLength se počítá každý 8bitový znak. To znamená, že hlavní a koncový bajt v jednom vícebajtovém znaku se počítají jako dva bajty. Podívejte se FreeExtra na příklad volání této funkce.

`CSimpleStringT::GetManager`

Načte správce paměti objektu CSimpleStringT .

Syntaxe

IAtlStringMgr* GetManager() const throw();

Návratová hodnota

Ukazatel na správce paměti pro CSimpleStringT objekt.

Poznámky

Voláním této metody načtěte správce paměti používaný objektem CSimpleStringT . Další informace o správcích paměti a řetězcových objektech naleznete v tématu Správa paměti a CStringT.

`CSimpleStringT::GetString`

Načte řetězec znaků.

Syntaxe

PCXSTR GetString() const throw();

Návratová hodnota

Ukazatel na řetězec znaků ukončený hodnotou null.

Poznámky

Voláním této metody načtěte řetězec znaků přidružený k objektu CSimpleStringT .

Poznámka:

Vrácený PCXSTR ukazatel je const a neumožňuje přímé úpravy CSimpleStringT obsahu.

Příklad

Následující příklad ukazuje použití CSimpleStringT::GetString.

CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();   
CSimpleString str(pMgr);
str += _T("Cup soccer is best!");
_tprintf_s(_T("%s"), str.GetString());

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

Cup soccer is best!

`CSimpleStringT::IsEmpty`

Otestuje CSimpleStringT objekt pro prázdnou podmínku.

Syntaxe

bool IsEmpty() const throw();

Návratová hodnota

Vrátí TRUE , pokud má objekt délku CSimpleStringT 0; jinak FALSE.

Poznámky

Voláním této metody určíte, zda objekt obsahuje prázdný řetězec.

Příklad

Následující příklad ukazuje použití CSimpleStringT::IsEmpty.

CSimpleString s(pMgr);
ASSERT(s.IsEmpty());

`CSimpleStringT::LockBuffer`

Zakáže počítání odkazů a chrání řetězec v vyrovnávací paměti.

Syntaxe

PXSTR LockBuffer();

Návratová hodnota

Ukazatel na CSimpleStringT objekt nebo řetězec ukončený hodnotou null.

Poznámky

Voláním této metody zamknete vyrovnávací paměť objektu CSimpleStringT . Zavoláním LockBuffervytvoříte kopii řetězce s číslem -1 pro počet odkazů. Pokud je hodnota počtu odkazů -1, řetězec v vyrovnávací paměti se považuje za "uzamčený". V uzamčeném stavu je řetězec chráněn dvěma způsoby:

Žádný jiný řetězec nemůže získat odkaz na data v zamknutém řetězci, i když je tento řetězec přiřazen k zamknutému řetězci.
Uzamčený řetězec nikdy neodkazuje na jiný řetězec, i když se tento druhý řetězec zkopíruje do uzamčeného řetězce.

Uzamčením řetězce v vyrovnávací paměti zajistíte, že výhradní blokování řetězce v vyrovnávací paměti zůstane nedotčené.

Po dokončení LockBuffervolání UnlockBuffer pro resetování počtu odkazů na 1.

Poznámka:

Pokud voláte GetBuffer uzamčenou vyrovnávací paměť a nastavíte GetBuffer parametr nMinBufferLength na větší než délka aktuální vyrovnávací paměti, ztratíte zámek vyrovnávací paměti. Takové volání GetBuffer zničí aktuální vyrovnávací paměť, nahradí ji vyrovnávací pamětí požadované velikosti a resetuje počet odkazů na nulu.

Další informace o počítání odkazů najdete v následujících článcích:

Správa životností objektů prostřednictvím počítání odkazů v sadě Windows SDK
Implementace počítání odkazů v sadě Windows SDK
Pravidla pro správu počtu odkazů v sadě Windows SDK

Příklad

Následující příklad ukazuje použití CSimpleStringT::LockBuffer.

CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();

CSimpleString str(_T("Hello"), pMgr);
TCHAR ch;

str.LockBuffer();
ch = str.GetAt(2);
_tprintf_s(_T("%c"), ch);
str.UnlockBuffer();

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

`CSimpleStringT::operator[]`

Volání této funkce pro přístup k jednomu znaku pole znaků.

Syntaxe

XCHAR operator[](int iChar) const;

Parametry

iChar
Index znaku v řetězci založený na nule.

Poznámky

Operátor přetížené dolní index ([]) vrátí jeden znak určený indexem založeným na nule v iChar. Tento operátor je praktickou náhradou GetAt členské funkce.

Poznámka:

Pomocí operátoru dolního indexu[] () můžete získat hodnotu znaku v objektu CSimpleStringT, ale nemůžete jej použít ke změně hodnoty znaku v objektu CSimpleStringT.

Příklad

Následující příklad ukazuje použití CSimpleStringT::operator [].

CSimpleString s(_T("abc"), pMgr);
ASSERT(s[1] == _T('b'));

`CSimpleStringT::operator []`

Volání této funkce pro přístup k jednomu znaku pole znaků.

Syntaxe

XCHAR operator[](int iChar) const;

Parametry

iChar
Index znaku v řetězci založený na nule.

Poznámky

Operátor přetížené dolní index ([]) vrátí jeden znak určený indexem založeným na nule v iChar. Tento operátor je praktickou náhradou GetAt členské funkce.

Poznámka:

Pomocí operátoru dolního indexu[] () můžete získat hodnotu znaku v objektu CSimpleStringT, ale nemůžete jej použít ke změně hodnoty znaku v objektu CSimpleStringT.

`CSimpleStringT::operator +=`

Spojí nový řetězec nebo znak na konec existujícího řetězce.

Syntaxe

CSimpleStringT& operator +=(PCXSTR pszSrc);
CSimpleStringT& operator +=(const CSimpleStringT& strSrc);
template<int t_nSize>
CSimpleStringT& operator+=(const CStaticString< XCHAR, t_nSize >& strSrc);
CSimpleStringT& operator +=(char ch);
CSimpleStringT& operator +=(unsigned char ch);
CSimpleStringT& operator +=(wchar_t ch);

Parametry

pszSrc
Ukazatel na řetězec ukončený hodnotou null.

strSrc
Ukazatel na existující CSimpleStringT objekt.

ch
Znak, který se má připojit.

Poznámky

Operátor přijímá jiný CSimpleStringT objekt nebo znak. Upozorňujeme, že výjimky paměti mohou nastat při každém použití tohoto operátoru zřetězení, protože nové úložiště může být přiděleno pro znaky přidané do tohoto CSimpleStringT objektu.

Příklad

Následující příklad ukazuje použití CSimpleStringT::operator +=.

CSimpleString str(_T("abc"), pMgr);
ASSERT(_tcscmp((str += _T("def")), _T("abcdef")) == 0);

`CSimpleStringT::operator =`

Přiřadí objektu novou hodnotu CSimpleStringT .

Syntaxe

CSimpleStringT& operator =(PCXSTR pszSrc);
CSimpleStringT& operator =(const CSimpleStringT& strSrc);

Parametry

pszSrc
Ukazatel na řetězec ukončený hodnotou null.

strSrc
Ukazatel na existující CSimpleStringT objekt.

Poznámky

Pokud je cílový řetězec (levá strana) už dostatečně velký k uložení nových dat, neprovádí se přidělení nové paměti. Všimněte si, že výjimky paměti mohou nastat vždy, když použijete operátor přiřazení, protože nové úložiště je často přiděleno k uložení výsledného CSimpleStringT objektu.

Příklad

Následující příklad ukazuje použití CSimpleStringT::operator =.

CSimpleString s1(pMgr), s2(pMgr);
// Empty CSimpleStringT objects

s1 = _T("cat");
// s1 = "cat"
ASSERT(_tcscmp(s1, _T("cat")) == 0);

s2 = s1;               // s1 and s2 each = "cat"
ASSERT(_tcscmp(s2, _T("cat")) == 0);

s1 = _T("the ") + s1;
// Or expressions
ASSERT(_tcscmp(s1, _T("the cat")) == 0);

s1 = _T("x");
// Or just individual characters
ASSERT(_tcscmp(s1, _T("x")) == 0);

`CSimpleStringT::operator PCXSTR`

Přímo přistupuje ke znakům uloženým v objektu CSimpleStringT jako řetězec ve stylu jazyka C.

Syntaxe

operator PCXSTR() const throw();

Návratová hodnota

Ukazatel znaku na data řetězce.

Poznámky

Nejsou zkopírovány žádné znaky; je vrácen pouze ukazatel. U tohoto operátoru buďte opatrní. Pokud po získání znakového CString ukazatele změníte objekt, může dojít k reálné poloze paměti, která ukazatel zneplatní.

Příklad

Následující příklad ukazuje použití CSimpleStringT::operator PCXSTR.

// If the prototype of a function is known to the compiler,
// the PCXSTR cast operator may be invoked implicitly.

CSimpleString strSports(L"Soccer is Best!", pMgr);
WCHAR sz[1024];

wcscpy_s(sz, strSports);

// If the prototype isn't known or is a va_arg prototype,
// you must invoke the cast operator explicitly. For example,
// the va_arg part of a call to swprintf_s() needs the cast:

swprintf_s(sz, 1024, L"I think that %s!\n", (PCWSTR)strSports);

// While the format parameter is known to be an PCXSTR and
// therefore doesn't need the cast:

swprintf_s(sz, 1024, strSports);

// Note that some situations are ambiguous. This line will
// put the address of the strSports object to stdout:

wcout << strSports;

// while this line will put the content of the string out:

wcout << (PCWSTR)strSports;

`CSimpleStringT::PCXSTR`

Ukazatel na konstantní řetězec.

Syntaxe

typedef ChTraitsBase< BaseType >::PCXSTR PCXSTR;

`CSimpleStringT::Preallocate`

Přidělí určité množství bajtů objektu CSimpleStringT .

Syntaxe

void Preallocate( int nLength);

Parametry

nLength
Přesná velikost CSimpleStringT vyrovnávací paměti znaků ve znaznach.

Poznámky

Voláním této metody přidělte konkrétní velikost vyrovnávací paměti pro CSimpleStringT objekt.

CSimpleStringT vygeneruje STATUS_NO_MEMORY výjimku, pokud není možné přidělit místo pro vyrovnávací paměť znaků. Ve výchozím nastavení přidělení paměti provádí funkce HeapAlloc rozhraní API WIN32 nebo HeapReAlloc.

Příklad

Následující příklad ukazuje použití CSimpleStringT::Preallocate.

CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();

CSimpleString str(pMgr);
_tprintf_s(_T("Allocated length: %d\n"), str.GetAllocLength());
str.Preallocate(100);
_tprintf_s(_T("Allocated length: %d\n"), str.GetAllocLength());

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

Allocated length: 0
Allocated length: 103

`CSimpleStringT::PXSTR`

Ukazatel na řetězec.

Syntaxe

typedef ChTraitsBase< BaseType >::PXSTR PXSTR;

`CSimpleStringT::ReleaseBuffer`

Uvolní kontrolu vyrovnávací paměti přidělené GetBuffer.

Syntaxe

void ReleaseBuffer(int nNewLength = -1);

Parametry

nNewLength
Nová délka řetězce v značce, nepočítá se ukončovací znak null. Pokud je řetězec ukončen null, výchozí hodnota -1 nastaví CSimpleStringT velikost na aktuální délku řetězce.

Poznámky

Voláním této metody lze relokovat nebo uvolnit vyrovnávací paměť řetězcového objektu. Pokud víte, že řetězec v vyrovnávací paměti je ukončen null, můžete vynechat nNewLength argument. Pokud váš řetězec není ukončený hodnotou null, použijte nNewLength k určení jeho délky. Adresa vrácená voláním ReleaseBuffer nebo jinou GetBuffer CSimpleStringT operací je neplatná.

Příklad

Následující příklad ukazuje použití CSimpleStringT::ReleaseBuffer.

const int bufferSize = 1024;
CSimpleString s(_T("abc"), pMgr);
LPTSTR p = s.GetBuffer(bufferSize);
_tcscpy_s(p, bufferSize, _T("abc"));

// use the buffer directly
ASSERT(s.GetLength() == 3);

// String length = 3
s.ReleaseBuffer();

// Surplus memory released, p is now invalid.
ASSERT(s.GetLength() == 3);

// Length still 3

`CSimpleStringT::ReleaseBufferSetLength`

Uvolní kontrolu vyrovnávací paměti přidělené GetBuffer.

Syntaxe

void ReleaseBufferSetLength(int nNewLength);

Parametry

nNewLength
Délka uvolněného řetězce

Poznámky

Tato funkce je funkčně podobná ReleaseBuffer s tím rozdílem, že musí být předána platná délka objektu string.

`CSimpleStringT::SetAt`

Nastaví jeden znak z objektu CSimpleStringT .

Syntaxe

void SetAt(int iChar, XCHAR ch);

Parametry

iChar
Index znaku v objektu CSimpleStringT založený na nule. Parametr iChar musí být větší nebo roven 0 a menší než hodnota vrácená GetLengthhodnotou .

ch
Nový znak.

Poznámky

Voláním této metody přepíšete znak umístěný v iChar. Tato metoda nezvětší řetězec, pokud iChar překročí hranice existujícího řetězce.

Příklad

Následující příklad ukazuje použití CSimpleStringT::SetAt.

CSimpleString s(_T("abcdef"), pMgr);
s.SetAt(1, _T('a'));
ASSERT(_tcscmp(s, _T("aacdef")) == 0);

`CSimpleStringT::SetManager`

Určuje správce paměti objektu CSimpleStringT .

Syntaxe

void SetManager(IAtlStringMgr* pStringMgr);

Parametry

pStringMgr
Ukazatel na nového správce paměti.

Poznámky

Voláním této metody určíte nového správce paměti, který objekt CSimpleStringT používá. Další informace o správcích paměti a řetězcových objektech naleznete v tématu Správa paměti a CStringT.

Příklad

Následující příklad ukazuje použití CSimpleStringT::SetManager.

CSimpleString s(pMgr);
s.SetManager(pCustomMgr);

`CSimpleStringT::SetString`

Nastaví řetězec objektu CSimpleStringT .

Syntaxe

void SetString(PCXSTR pszSrc, int nLength);
void SetString(PCXSTR pszSrc);

Parametry

pszSrc
Ukazatel na řetězec ukončený hodnotou null.

nLength
Početznakůchch pszSrc

Poznámky

Zkopírujte do objektu CSimpleStringT řetězec. SetString přepíše starší řetězcová data ve vyrovnávací paměti.

Obě verze kontrolují SetString , jestli pszSrc je ukazatel null, a pokud ano, vyvolá E_INVALIDARG chybu.

Verze s jedním parametrem SetString pszSrc očekává, že odkazuje na řetězec ukončený hodnotou null.

Verze dvou parametrů SetString také očekává pszSrc , že bude řetězec ukončený hodnotou null. Používá nLength se jako délka řetězce, pokud se nejprve nenarazí na ukončovací znak null.

Verze dvou parametrů SetString také kontroluje, zda pszSrc odkazuje na umístění v aktuální vyrovnávací paměti v CSimpleStringT. V tomto speciálním případě používá funkci kopírování paměti, SetString která nepřepíše řetězcová data při kopírování řetězcových dat zpět do vyrovnávací paměti.

Příklad

Následující příklad ukazuje použití CSimpleStringT::SetString.

CSimpleString s(_T("abcdef"), pMgr);
ASSERT(_tcscmp(s, _T("abcdef")) == 0);
s.SetString(_T("Soccer"), 6);
ASSERT(_tcscmp(s, _T("Soccer")) == 0);

`CSimpleStringT::StringLength`

Vrátí počet znaků v zadaném řetězci.

Syntaxe

ATL_NOINLINE static int StringLength(PCXSTR psz) throw();

Parametry

psz
Ukazatel na řetězec ukončený hodnotou null.

Návratová hodnota

Početznakůch psz

Poznámky

Voláním této metody načtěte počet znaků v řetězci, na který pszodkazuje .

Příklad

Následující příklad ukazuje použití CSimpleStringT::StringLength.

ASSERT(CSimpleString::StringLength(_T("soccer")) == 6);

`CSimpleStringT::Truncate`

Zkrátí řetězec na novou délku.

Syntaxe

void Truncate(int nNewLength);

Parametry

nNewLength
Nová délka řetězce.

Poznámky

Voláním této metody zkrátíte obsah řetězce na novou délku.

Poznámka:

To nemá vliv na přidělenou délku vyrovnávací paměti. Chcete-li snížit nebo zvýšit aktuální vyrovnávací paměť, viz FreeExtra a Preallocate.

Příklad

Následující příklad ukazuje použití CSimpleStringT::Truncate.

CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str(_T("abcdefghi"), pMgr);
_tprintf_s(_T("String length: %d / Allocated length: %d\n"), str.GetLength(), str.GetAllocLength());
_tprintf_s(_T("Contents: %s\n"), (LPCTSTR)str);
str.Truncate(4);
_tprintf_s(_T("String length: %d / Allocated length: %d\n"), str.GetLength(), str.GetAllocLength());
_tprintf_s(_T("Contents: %s\n"), (LPCTSTR)str);

Výstup z tohoto příkladu je:

String length: 9 / Allocated length: 15
Contents: abcdefghi
String length: 4 / Allocated length: 15
Contents: abcd

`CSimpleStringT::UnlockBuffer`

Odemkne vyrovnávací paměť objektu CSimpleStringT .

Syntaxe

void UnlockBuffer() throw();

Poznámky

Voláním této metody resetujte počet odkazů řetězce na hodnotu 1.

Destruktor CSimpleStringT automaticky volá UnlockBuffer , aby se zajistilo, že vyrovnávací paměť není uzamčena při volání destruktoru. Příklad této metody naleznete v tématu LockBuffer.

`CSimpleStringT::~CSimpleStringT`

CSimpleStringT Zničí objekt.

Syntaxe

~CSimpleStringT() throw();

Poznámky

Voláním této metody zničíte CSimpleStringT objekt.

Viz také

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

Sdílet prostřednictvím

CSimpleStringT Třída

Syntaxe

Parametry

Členové

Veřejné definice typedef

Veřejné konstruktory

Veřejné metody

Veřejné operátory

Poznámky

Požadavky

CSimpleStringT::Append

Syntaxe

Parametry

Poznámky

Příklad

CSimpleStringT::AppendChar

Syntaxe

Parametry

Poznámky

CSimpleStringT::CopyChars

Syntaxe

Parametry

Poznámky

Příklad

CSimpleStringT::CopyCharsOverlapped

Syntaxe

Parametry

Poznámky

Příklad

CSimpleStringT::CSimpleStringT

Syntaxe

Parametry

Poznámky

Příklad

CSimpleStringT::Empty

Syntaxe

Poznámky

Příklad

CSimpleStringT::FreeExtra

Syntaxe

Poznámky

Příklad

CSimpleStringT::GetAllocLength

Syntaxe

Návratová hodnota

Poznámky

CSimpleStringT::GetAt

Syntaxe

Parametry

Návratová hodnota

Poznámky

Příklad

CSimpleStringT::GetBuffer

Syntaxe

Parametry

Návratová hodnota

Poznámky

Příklad

CSimpleStringT::GetBufferSetLength

Syntaxe

Parametry

Návratová hodnota

Poznámky

Příklad

CSimpleStringT::GetLength

Syntaxe

Návratová hodnota

Poznámky

CSimpleStringT::GetManager

Syntaxe

Návratová hodnota

Poznámky

CSimpleStringT::GetString

Syntaxe

Návratová hodnota

Poznámky

Příklad

CSimpleStringT::IsEmpty

Syntaxe

`CSimpleStringT` Třída

`CSimpleStringT::Append`

`CSimpleStringT::AppendChar`

`CSimpleStringT::CopyChars`

`CSimpleStringT::CopyCharsOverlapped`

`CSimpleStringT::CSimpleStringT`

`CSimpleStringT::Empty`

`CSimpleStringT::FreeExtra`

`CSimpleStringT::GetAllocLength`

`CSimpleStringT::GetAt`

`CSimpleStringT::GetBuffer`

`CSimpleStringT::GetBufferSetLength`

`CSimpleStringT::GetLength`

`CSimpleStringT::GetManager`

`CSimpleStringT::GetString`

`CSimpleStringT::IsEmpty`

`CSimpleStringT::LockBuffer`

`CSimpleStringT::operator[]`

`CSimpleStringT::operator []`

`CSimpleStringT::operator +=`

`CSimpleStringT::operator =`

`CSimpleStringT::operator PCXSTR`

`CSimpleStringT::PCXSTR`

`CSimpleStringT::Preallocate`

`CSimpleStringT::PXSTR`

`CSimpleStringT::ReleaseBuffer`

`CSimpleStringT::ReleaseBufferSetLength`

`CSimpleStringT::SetAt`

`CSimpleStringT::SetManager`

`CSimpleStringT::SetString`

`CSimpleStringT::StringLength`