`CSimpleStringT`-klass

Den här klassen representerar ett CSimpleStringT objekt.

Syntax

template <typename BaseType>
class CSimpleStringT

Parameterar

BaseType
Strängklassens teckentyp. Kan vara något av följande:

char (för ANSI-teckensträngar).
wchar_t (för Unicode-teckensträngar).
TCHAR (för både ANSI- och Unicode-teckensträngar).

Medlemmar

Offentliga typedefs

Namn	Beskrivning
`CSimpleStringT::PCXSTR`	En pekare till en konstant sträng.
`CSimpleStringT::PXSTR`	En pekare till en sträng.

Offentliga konstruktorer

Namn	Beskrivning
`CSimpleStringT::CSimpleStringT`	Konstruerar `CSimpleStringT` objekt på olika sätt.
`CSimpleStringT::~CSimpleStringT`	Destructor.

Offentliga metoder

Namn	Beskrivning
`CSimpleStringT::Append`	Lägger till ett `CSimpleStringT` objekt i ett befintligt `CSimpleStringT` objekt.
`CSimpleStringT::AppendChar`	Lägger till ett tecken i ett befintligt `CSimpleStringT` objekt.
`CSimpleStringT::CopyChars`	Kopierar ett tecken eller tecken till en annan sträng.
`CSimpleStringT::CopyCharsOverlapped`	Kopierar ett tecken eller tecken till en annan sträng där buffertarna överlappar varandra.
`CSimpleStringT::Empty`	Tvingar en sträng att ha en längd på noll.
`CSimpleStringT::FreeExtra`	Frigör extra minne som tidigare allokerats av strängobjektet.
`CSimpleStringT::GetAllocLength`	Hämtar den allokerade längden på ett `CSimpleStringT` objekt.
`CSimpleStringT::GetAt`	Returnerar tecknet vid en viss position.
`CSimpleStringT::GetBuffer`	Returnerar en pekare till tecknen i en `CSimpleStringT`.
`CSimpleStringT::GetBufferSetLength`	Returnerar en pekare till tecknen i en `CSimpleStringT`, som trunkerar till den angivna längden.
`CSimpleStringT::GetLength`	Returnerar antalet tecken i ett `CSimpleStringT` objekt.
`CSimpleStringT::GetManager`	Hämtar objektets minneshanterare `CSimpleStringT` .
`CSimpleStringT::GetString`	Hämtar teckensträngen
`CSimpleStringT::IsEmpty`	Testar om ett `CSimpleStringT` objekt inte innehåller några tecken.
`CSimpleStringT::LockBuffer`	Inaktiverar referensräkning och skyddar strängen i bufferten.
`CSimpleStringT::Preallocate`	Allokerar en viss mängd minne för teckenbufferten.
`CSimpleStringT::ReleaseBuffer`	Frigör kontroll över bufferten som returneras av `GetBuffer`.
`CSimpleStringT::ReleaseBufferSetLength`	Frigör kontroll över bufferten som returneras av `GetBuffer`.
`CSimpleStringT::SetAt`	Anger ett tecken vid en viss position.
`CSimpleStringT::SetManager`	Anger minneshanteraren för ett `CSimpleStringT` objekt.
`CSimpleStringT::SetString`	Anger strängen för ett `CSimpleStringT` objekt.
`CSimpleStringT::StringLength`	Returnerar antalet tecken i den angivna strängen.
`CSimpleStringT::Truncate`	Trunkerar strängen till en angiven längd.
`CSimpleStringT::UnlockBuffer`	Aktiverar referensräkning och släpper strängen i bufferten.

Offentliga operatörer

Namn	Beskrivning
`CSimpleStringT::operator PCXSTR`	Direktåtkomst till tecken som lagras i ett `CSimpleStringT` objekt som en C-sträng.
`CSimpleStringT::operator[]`	Returnerar tecknet vid en given position – operatorersättning för `GetAt`.
`CSimpleStringT::operator +=`	Sammanfogar en ny sträng till slutet av en befintlig sträng.
`CSimpleStringT::operator =`	Tilldelar ett nytt värde till ett `CSimpleStringT` objekt.

Anmärkningar

CSimpleStringT är basklassen för de olika strängklasser som stöds av Visual C++. Det ger minimalt stöd för minneshantering av strängobjektet och grundläggande buffertmanipulering. Mer avancerade strängobjekt finns i CStringT Class.

Kravspecifikation

rubrik:atlsimpstr.h

`CSimpleStringT::Append`

Lägger till ett CSimpleStringT objekt i ett befintligt CSimpleStringT objekt.

Syntax

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

Parameterar

strSrc
Det CSimpleStringT objekt som ska läggas till.

pszSrc
En pekare till en sträng som innehåller de tecken som ska läggas till.

nLength
Antalet tecken som ska läggas till.

Anmärkningar

Anropa den här metoden för att lägga till ett befintligt CSimpleStringT objekt i ett annat CSimpleStringT objekt.

Exempel

I följande exempel visas användningen av 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`

Lägger till ett tecken i ett befintligt CSimpleStringT objekt.

Syntax

void AppendChar(XCHAR ch);

Parameterar

ch
Tecknet som ska läggas till

Anmärkningar

Anropa den här funktionen för att lägga till det angivna tecknet i slutet av ett befintligt CSimpleStringT objekt.

`CSimpleStringT::CopyChars`

Kopierar ett tecken eller tecken till ett CSimpleStringT objekt.

Syntax

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

Parameterar

pchDest
En pekare till en teckensträng.

nDestLen
Buffertstorlek på pchDest

pchSrc
En pekare till en sträng som innehåller de tecken som ska kopieras.

nChars
Antalet pchSrc tecken som ska kopieras.

Anmärkningar

Anropa den här metoden för att kopiera tecken från pchSrc till strängen pchDest .

Exempel

I följande exempel visas användningen av 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);

Utdata från det här exemplet är följande:

xxxxxxxxxxxxxxxxxxx
Hello world!xxxxxxx

`CSimpleStringT::CopyCharsOverlapped`

Kopierar ett tecken eller tecken till ett CSimpleStringT objekt.

Syntax

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

Parameterar

pchDest
En pekare till en teckensträng.

pchSrc
En pekare till en sträng som innehåller de tecken som ska kopieras.

nChars
Antalet pchSrc tecken som ska kopieras.

Anmärkningar

Anropa den här metoden för att kopiera tecken från pchSrc till strängen pchDest . Till skillnad från CopyChars, CopyCharsOverlapped tillhandahåller en säker metod för att kopiera från teckenbuffertar som kan vara överlappade.

Exempel

Se exemplet för CSimpleStringT::CopyChars, eller källkoden för CSimpleStringT::SetString (finns i atlsimpstr.h).

`CSimpleStringT::CSimpleStringT`

Konstruerar ett CSimpleStringT objekt.

Syntax

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

Parameterar

strSrc
Ett befintligt CSimpleStringT objekt som ska kopieras till det här CSimpleStringT objektet.

pchSrc
En pekare till en matris med tecken med längden nLength, inte null avslutad.

pszSrc
En null-avslutad sträng som ska kopieras till det här CSimpleStringT objektet.

nLength
Antal tecken i pch.

pStringMgr
En pekare till objektets CSimpleStringT minneshanterare. Mer information om IAtlStringMgr och minneshantering för CSimpleStringTfinns i Minneshantering och CStringT.

Anmärkningar

Konstruera ett nytt CSimpleStringT objekt. Eftersom konstruktorerna kopierar indata till ny allokerad lagring kan minnesfel uppstå.

Exempel

I följande exempel visas användningen av med hjälp av CSimpleStringT::CSimpleStringT ATL typedefCSimpleString. CSimpleString är en vanlig specialisering av klassmallen CSimpleStringT.

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`

Gör det här CSimpleStringT objektet till en tom sträng och frigör minne efter behov.

Syntax

void Empty() throw();

Anmärkningar

Mer information finns i Strängar: CString Undantagsrensning.

Exempel

I följande exempel visas användningen av CSimpleStringT::Empty.

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

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

`CSimpleStringT::FreeExtra`

Frigör extra minne som tidigare allokerats av strängen men som inte längre behövs.

Syntax

void FreeExtra();

Anmärkningar

Detta bör minska mängden minne som förbrukas av strängobjektet. Metoden omallokerar bufferten till den exakta längden som returneras av GetLength.

Exempel

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

Utdata från det här exemplet är följande:

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`

Hämtar den allokerade längden på ett CSimpleStringT objekt.

Syntax

int GetAllocLength() const throw();

Returvärde

Antalet tecken som allokerats för det här objektet.

Anmärkningar

Anropa den här metoden för att fastställa antalet tecken som allokerats för det här CSimpleStringT objektet. Se FreeExtra ett exempel på hur du anropar den här funktionen.

`CSimpleStringT::GetAt`

Returnerar ett tecken från ett CSimpleStringT objekt.

Syntax

XCHAR GetAt(int iChar) const;

Parameterar

iChar
Nollbaserat index för tecknet i CSimpleStringT objektet. Parametern iChar måste vara större än eller lika med 0 och mindre än värdet som returneras av GetLength. Annars GetAt genererar ett undantag.

Returvärde

En XCHAR som innehåller tecknet vid den angivna positionen i strängen.

Anmärkningar

Anropa den här metoden för att returnera det enda tecken som anges av iChar. Operatorn för överlagrade nedsänkta ([]) är ett praktiskt alias för GetAt. Null-avslutaren kan adresseras utan att generera ett undantag med hjälp GetAtav . Det räknas dock inte av GetLengthoch värdet som returneras är 0.

Exempel

I följande exempel visas hur du använder CSimpleStringT::GetAt.

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

`CSimpleStringT::GetBuffer`

Returnerar en pekare till objektets CSimpleStringT interna teckenbuffert.

Syntax

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

Parameterar

nMinBufferLength
Det minsta antalet tecken som teckenbufferten kan innehålla. Det här värdet innehåller inte utrymme för en null-avslutare.

Om nMinBufferLength är större än längden på den aktuella bufferten förstör GetBuffer den aktuella bufferten, ersätter den med en buffert av den begärda storleken och återställer antalet objektreferenser till noll. Om du tidigare har anropat LockBuffer den här bufferten förlorar du buffertlåset.

Returvärde

En PXSTR pekare till objektets (null-avslutade) teckenbuffert.

Anmärkningar

Anropa den här metoden för att returnera buffertinnehållet i CSimpleStringT objektet. Den returnerade PXSTR är inte en konstant och tillåter därför direkt ändring av CSimpleStringT innehållet.

Om du använder pekaren som returneras av GetBuffer för att ändra stränginnehållet måste du anropa ReleaseBuffer för att uppdatera det interna tillståndet CSimpleStringT för innan du använder andra CSimpleStringT metoder.

Den adress som returneras av GetBuffer kanske inte är giltig efter anropet till ReleaseBuffer eftersom ytterligare CSimpleStringT åtgärder kan göra så att bufferten CSimpleStringT omallokeras. Bufferten omallokeras inte om du inte ändrar längden på CSimpleStringT.

Buffertminnet frigörs automatiskt när objektet CSimpleStringT förstörs.

Om du håller reda på stränglängden själv bör du inte lägga till det avslutande null-tecknet. Du måste dock ange den sista stränglängden när du släpper bufferten med ReleaseBuffer. Om du lägger till ett avslutande null-tecken bör du skicka -1 (standard) för längden. ReleaseBuffer avgör sedan buffertlängden.

Om det inte finns tillräckligt med minne för att uppfylla GetBuffer begäran, genererar den här metoden en CMemoryException*.

Exempel

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`

Returnerar en pekare till den interna teckenbufferten CSimpleStringT för objektet, trunkerar eller ökar dess längd om det behövs för att exakt matcha längden som anges i nLength.

Syntax

PXSTR GetBufferSetLength(int nLength);

Parameterar

nLength
Den exakta storleken på teckenbufferten CSimpleStringT i tecken.

Returvärde

En PXSTR pekare till objektets (null-avslutade) teckenbuffert.

Anmärkningar

Anropa den här metoden för att hämta en angiven längd på objektets CSimpleStringT interna buffert. Den returnerade PXSTR pekaren är inte const och tillåter därför direkt ändring av CSimpleStringT innehållet.

Om du använder pekaren som returneras av GetBufferSetLength för att ändra stränginnehållet anropar ReleaseBuffer du för att uppdatera det interna tillståndet CSimpleStringT för innan du använder andra CSimpleStringT metoder.

Den adress som returneras av GetBufferSetLength kanske inte är giltig efter anropet till ReleaseBuffer eftersom ytterligare CSimpleStringT åtgärder kan göra så att bufferten CSimpleStringT omallokeras. Bufferten tilldelas inte om du inte ändrar längden på CSimpleStringT.

Buffertminnet frigörs automatiskt när objektet CSimpleStringT förstörs.

Om du håller reda på stränglängden själv ska du inte lägga till det avslutande null-tecknet. Du måste ange den sista stränglängden när du släpper bufferten med hjälp ReleaseBufferav . Om du lägger till ett avslutande null-tecken när du anropar ReleaseBufferskickar du -1 (standard) för längden till ReleaseBufferoch ReleaseBuffer utför en strlen på bufferten för att fastställa dess längd.

Mer information om referensräkning finns i följande artiklar:

Hantera objektlivslängder via referensräkning i Windows SDK.
Implementera referensräkning i Windows SDK.
Regler för att hantera referensantal i Windows SDK.

Exempel

I följande exempel visas användningen av 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`

Returnerar antalet tecken i CSimpleStringT objektet.

Syntax

int GetLength() const throw();

Returvärde

Antal tecken i strängen.

Anmärkningar

Anropa den här metoden för att returnera antalet tecken i objektet. Antalet inkluderar inte en null-avslutare.

För flerbytesteckenuppsättningar (MBCS) GetLength räknas varje 8-bitars tecken, dvs. en lead- och trail-byte i ett flerbytestecken räknas som två byte. Se FreeExtra ett exempel på hur du anropar den här funktionen.

`CSimpleStringT::GetManager`

Hämtar objektets minneshanterare CSimpleStringT .

Syntax

IAtlStringMgr* GetManager() const throw();

Returvärde

En pekare till minneshanteraren för CSimpleStringT objektet.

Anmärkningar

Anropa den här metoden för att hämta minneshanteraren som används av CSimpleStringT objektet. Mer information om minneshanterare och strängobjekt finns i Minneshantering och CStringT.

`CSimpleStringT::GetString`

Hämtar teckensträngen.

Syntax

PCXSTR GetString() const throw();

Returvärde

En pekare till en null-avslutad teckensträng.

Anmärkningar

Anropa den här metoden för att hämta teckensträngen CSimpleStringT som är associerad med objektet.

Anmärkning

Den returnerade PCXSTR pekaren är const och tillåter inte direkt ändring av CSimpleStringT innehållet.

Exempel

I följande exempel visas användningen av CSimpleStringT::GetString.

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

Utdata från det här exemplet är följande:

Cup soccer is best!

`CSimpleStringT::IsEmpty`

Testar ett CSimpleStringT objekt för det tomma villkoret.

Syntax

bool IsEmpty() const throw();

Returvärde

Returnerar TRUE om objektet CSimpleStringT har 0 längd, annars FALSE.

Anmärkningar

Anropa den här metoden för att avgöra om objektet innehåller en tom sträng.

Exempel

I följande exempel visas användningen av CSimpleStringT::IsEmpty.

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

`CSimpleStringT::LockBuffer`

Inaktiverar referensräkning och skyddar strängen i bufferten.

Syntax

PXSTR LockBuffer();

Returvärde

En pekare till ett CSimpleStringT objekt eller en null-avslutad sträng.

Anmärkningar

Anropa den här metoden för att låsa bufferten för CSimpleStringT objektet. Genom att anropa LockBufferskapar du en kopia av strängen med en -1 för referensantalet. När referensantalvärdet är -1 anses strängen i bufferten vara i ett "låst" tillstånd. När strängen är i ett låst tillstånd skyddas den på två sätt:

Ingen annan sträng kan hämta en referens till data i den låsta strängen, även om strängen har tilldelats till den låsta strängen.
Den låsta strängen refererar aldrig till en annan sträng, även om den andra strängen kopieras till den låsta strängen.

Genom att låsa strängen i bufferten ser du till att strängens exklusiva undantag för bufferten förblir intakt.

När du är klar med LockBufferanropar UnlockBuffer du för att återställa referensantalet till 1.

Anmärkning

Om du anropar GetBuffer en låst buffert och anger parametern GetBuffernMinBufferLength till större än längden på den aktuella bufferten förlorar du buffertlåset. Ett sådant anrop till GetBuffer förstör den aktuella bufferten, ersätter den med en buffert av den begärda storleken och återställer referensantalet till noll.

Mer information om referensräkning finns i följande artiklar:

Hantera objektlivslängder via referensräkning i Windows SDK
Implementera referensräkning i Windows SDK
Regler för att hantera referensantal i Windows SDK

Exempel

I följande exempel visas användningen av 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();

Utdata från det här exemplet är följande:

`CSimpleStringT::operator[]`

Anropa den här funktionen för att få åtkomst till ett enda tecken i teckenmatrisen.

Syntax

XCHAR operator[](int iChar) const;

Parameterar

iChar
Nollbaserat index för ett tecken i strängen.

Anmärkningar

Operatorn överlagrad nedsänkt ([]) returnerar ett enda tecken som anges av det nollbaserade indexet i iChar. Den här operatorn är en praktisk ersättning för GetAt medlemsfunktionen.

Anmärkning

Du kan använda operatorn subscript ([]) för att hämta värdet för ett tecken i en CSimpleStringT, men du kan inte använda det för att ändra värdet för ett tecken i en CSimpleStringT.

Exempel

I följande exempel visas användningen av CSimpleStringT::operator [].

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

`CSimpleStringT::operator +=`

Kopplar en ny sträng eller ett nytt tecken till slutet av en befintlig sträng.

Syntax

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

Parameterar

pszSrc
En pekare till en null-avslutad sträng.

strSrc
En pekare till ett befintligt CSimpleStringT objekt.

ch
Det tecken som ska läggas till.

Anmärkningar

Operatorn accepterar ett annat CSimpleStringT objekt eller ett tecken. Observera att minnesfel kan inträffa när du använder den här sammanfogningsoperatorn eftersom ny lagring kan allokeras för tecken som läggs till i det här CSimpleStringT objektet.

Exempel

I följande exempel visas användningen av CSimpleStringT::operator +=.

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

`CSimpleStringT::operator =`

Tilldelar ett nytt värde till ett CSimpleStringT objekt.

Syntax

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

Parameterar

pszSrc
En pekare till en null-avslutad sträng.

strSrc
En pekare till ett befintligt CSimpleStringT objekt.

Anmärkningar

Om målsträngen (vänster sida) redan är tillräckligt stor för att lagra nya data utförs ingen ny minnesallokering. Observera att minnesfel kan inträffa när du använder tilldelningsoperatorn eftersom ny lagring ofta allokeras för att lagra det resulterande CSimpleStringT objektet.

Exempel

I följande exempel visas användningen av 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`

Direktåtkomst till tecken som lagras i ett CSimpleStringT objekt som en C-sträng.

Syntax

operator PCXSTR() const throw();

Returvärde

En teckenpekare till strängens data.

Anmärkningar

Inga tecken kopieras. endast en pekare returneras. Var försiktig med den här operatorn. Om du ändrar ett CString objekt när du har hämtat teckenpekaren kan du orsaka en omfördelning av minnet som ogiltigförklarar pekaren.

Exempel

I följande exempel visas användningen av 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`

En pekare till en konstant sträng.

Syntax

typedef ChTraitsBase< BaseType >::PCXSTR PCXSTR;

`CSimpleStringT::Preallocate`

Allokerar en viss mängd byte för CSimpleStringT objektet.

Syntax

void Preallocate( int nLength);

Parameterar

nLength
Den exakta storleken på teckenbufferten CSimpleStringT i tecken.

Anmärkningar

Anropa den här metoden för att allokera en specifik buffertstorlek för CSimpleStringT objektet.

CSimpleStringT genererar ett STATUS_NO_MEMORY undantag om det inte går att allokera utrymme för teckenbufferten. Som standard utförs minnesallokering av WIN32 API-funktioner HeapAlloc eller HeapReAlloc.

Exempel

I följande exempel visas användningen av 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());

Utdata från det här exemplet är följande:

Allocated length: 0
Allocated length: 103

`CSimpleStringT::PXSTR`

En pekare till en sträng.

Syntax

typedef ChTraitsBase< BaseType >::PXSTR PXSTR;

`CSimpleStringT::ReleaseBuffer`

Frigör kontroll över bufferten som allokerats av GetBuffer.

Syntax

void ReleaseBuffer(int nNewLength = -1);

Parameterar

nNewLength
Den nya längden på strängen i tecken, utan att räkna en null-avslutare. Om strängen är null avslutad anger CSimpleStringT -1 standardvärde storleken till strängens aktuella längd.

Anmärkningar

Anropa den här metoden för att omallokera eller frigöra bufferten för strängobjektet. Om du vet att strängen i bufferten är null avslutad kan du utelämna nNewLength argumentet. Om strängen inte är null avslutad använder du nNewLength för att ange dess längd. Adressen som returneras av GetBuffer är ogiltig efter anropet till ReleaseBuffer eller någon annan CSimpleStringT åtgärd.

Exempel

I följande exempel visas användningen av 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`

Frigör kontroll över bufferten som allokerats av GetBuffer.

Syntax

void ReleaseBufferSetLength(int nNewLength);

Parameterar

nNewLength
Längden på strängen som släpps

Anmärkningar

Den här funktionen är funktionellt lik ReleaseBuffer förutom att en giltig längd för strängobjektet måste skickas.

`CSimpleStringT::SetAt`

Anger ett enskilt tecken från ett CSimpleStringT objekt.

Syntax

void SetAt(int iChar, XCHAR ch);

Parameterar

iChar
Nollbaserat index för tecknet i CSimpleStringT objektet. Parametern iChar måste vara större än eller lika med 0 och mindre än värdet som returneras av GetLength.

ch
Det nya tecknet.

Anmärkningar

Anropa den här metoden för att skriva över tecknet som finns på iChar. Den här metoden förstorar inte strängen om iChar den överskrider gränserna för den befintliga strängen.

Exempel

I följande exempel visas användningen av CSimpleStringT::SetAt.

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

`CSimpleStringT::SetManager`

Anger objektets minneshanterare CSimpleStringT .

Syntax

void SetManager(IAtlStringMgr* pStringMgr);

Parameterar

pStringMgr
En pekare till den nya minneshanteraren.

Anmärkningar

Anropa den här metoden för att ange en ny minneshanterare som används av CSimpleStringT objektet. Mer information om minneshanterare och strängobjekt finns i Minneshantering och CStringT.

Exempel

I följande exempel visas användningen av CSimpleStringT::SetManager.

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

`CSimpleStringT::SetString`

Anger strängen för ett CSimpleStringT objekt.

Syntax

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

Parameterar

pszSrc
En pekare till en null-avslutad sträng.

nLength
Antal tecken i pszSrc.

Anmärkningar

Kopiera en sträng till objektet CSimpleStringT . SetString skriver över äldre strängdata i bufferten.

Båda versionerna av SetString kontrollerar om pszSrc är en null-pekare, och om det är det utlöser du ett E_INVALIDARG fel.

Enparameterversionen av SetString förväntar sig pszSrc att peka på en null-avslutad sträng.

Tvåparameterversionen av SetString förväntar sig pszSrc också att vara en null-avslutad sträng. Den använder nLength som stränglängd om den inte stöter på en null-avslutare först.

Tvåparameterversionen av SetString kontrollerar också om pszSrc pekar på en plats i den aktuella bufferten i CSimpleStringT. I det här specialfallet SetString använder en minneskopieringsfunktion som inte skriver över strängdata när strängdata kopieras tillbaka till bufferten.

Exempel

I följande exempel visas användningen av 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`

Returnerar antalet tecken i den angivna strängen.

Syntax

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

Parameterar

psz
En pekare till en null-avslutad sträng.

Returvärde

Antalet tecken i psz; räknar inte en null-avslutare.

Anmärkningar

Anropa den här metoden för att hämta antalet tecken i strängen som pekas på av psz.

Exempel

I följande exempel visas användningen av CSimpleStringT::StringLength.

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

`CSimpleStringT::Truncate`

Trunkerar strängen till den nya längden.

Syntax

void Truncate(int nNewLength);

Parameterar

nNewLength
Strängens nya längd.

Anmärkningar

Anropa den här metoden för att trunkera innehållet i strängen till den nya längden.

Anmärkning

Detta påverkar inte buffertens allokerade längd. Information om hur du minskar eller ökar den aktuella bufferten finns i FreeExtra och Preallocate.

Exempel

I följande exempel visas användningen av 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);

Utdata från det här exemplet är:

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

`CSimpleStringT::UnlockBuffer`

Låser upp bufferten för CSimpleStringT objektet.

Syntax

void UnlockBuffer() throw();

Anmärkningar

Anropa den här metoden för att återställa referensantalet för strängen till 1.

Destructor CSimpleStringT anropar UnlockBuffer automatiskt för att säkerställa att bufferten inte är låst när destructor anropas. Ett exempel på den här metoden finns i LockBuffer.

`CSimpleStringT::~CSimpleStringT`

Förstör ett CSimpleStringT objekt.

Syntax

~CSimpleStringT() throw();

Anmärkningar

Anropa den här metoden för att förstöra objektet CSimpleStringT .

Se även

hierarkidiagram
DELADE ATL/MFC-klasser

Feedback

Var den här sidan till hjälp?

Last updated on 2025-11-07

Dela via

CSimpleStringT-klass

Syntax

Parameterar

Medlemmar

Offentliga typedefs

Offentliga konstruktorer

Offentliga metoder

Offentliga operatörer

Anmärkningar

Kravspecifikation

CSimpleStringT::Append

Syntax

Parameterar

Anmärkningar

Exempel

CSimpleStringT::AppendChar

Syntax

Parameterar

Anmärkningar

CSimpleStringT::CopyChars

Syntax

Parameterar

Anmärkningar

Exempel

CSimpleStringT::CopyCharsOverlapped

Syntax

Parameterar

Anmärkningar

Exempel

CSimpleStringT::CSimpleStringT

Syntax

Parameterar

Anmärkningar

Exempel

CSimpleStringT::Empty

Syntax

Anmärkningar

Exempel

CSimpleStringT::FreeExtra

Syntax

Anmärkningar

Exempel

CSimpleStringT::GetAllocLength

Syntax

Returvärde

Anmärkningar

CSimpleStringT::GetAt

Syntax

Parameterar

Returvärde

Anmärkningar

Exempel

CSimpleStringT::GetBuffer

Syntax

Parameterar

Returvärde

Anmärkningar

Exempel

CSimpleStringT::GetBufferSetLength

Syntax

Parameterar

Returvärde

Anmärkningar

Exempel

CSimpleStringT::GetLength

Syntax

Returvärde

Anmärkningar

CSimpleStringT::GetManager

Syntax

Returvärde

Anmärkningar

CSimpleStringT::GetString

Syntax

Returvärde

Anmärkningar

Exempel

CSimpleStringT::IsEmpty

Syntax

`CSimpleStringT`-klass

`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 PCXSTR`

`CSimpleStringT::PCXSTR`

`CSimpleStringT::Preallocate`

`CSimpleStringT::PXSTR`

`CSimpleStringT::ReleaseBuffer`

`CSimpleStringT::ReleaseBufferSetLength`

`CSimpleStringT::SetAt`

`CSimpleStringT::SetManager`

`CSimpleStringT::SetString`

`CSimpleStringT::StringLength`

`CSimpleStringT::Truncate`