CSimpleStringT osztály

Megjegyzés:

A Microsoft Foundation Classes (MFC) és az Active Template Library (ATL) továbbra is támogatott. A továbbiakban azonban nem adunk hozzá funkciókat, és nem frissítjük a dokumentációt.

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

Szemantika

template <typename BaseType>
class CSimpleStringT

Paraméterek

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

• char (ANSI-karaktersztringek esetén).

• wchar_t (Unicode-karaktersztringek esetén).

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

Tagok

Nyilvános typedefs

Név	Leírás
CSimpleStringT::PCXSTR	Egy állandó sztringre mutató mutató.
CSimpleStringT::PXSTR	Mutató egy sztringre.

Nyilvános konstruktorok

Név	Leírás
CSimpleStringT::CSimpleStringT	CSimpleStringT Különböző módokon építi fel az objektumokat.
CSimpleStringT::~CSimpleStringT	Destruktor.

Nyilvános metódusok

Név	Leírás
CSimpleStringT::Append	Objektum hozzáfűzése CSimpleStringT egy meglévő CSimpleStringT objektumhoz.
CSimpleStringT::AppendChar	Egy karakter hozzáfűzése egy meglévő CSimpleStringT objektumhoz.
CSimpleStringT::CopyChars	Karaktert vagy karaktert másol egy másik sztringbe.
CSimpleStringT::CopyCharsOverlapped	Egy karaktert vagy karaktert egy másik sztringbe másol, amelyben a pufferek átfedésben vannak.
CSimpleStringT::Empty	Egy sztringet nulla hosszúságúra kényszerít.
CSimpleStringT::FreeExtra	Felszabadítja a sztringobjektum által korábban lefoglalt további memóriát.
CSimpleStringT::GetAllocLength	Lekéri egy objektum lefoglalt hosszát CSimpleStringT .
CSimpleStringT::GetAt	Egy adott pozícióban lévő karaktert ad vissza.
CSimpleStringT::GetBuffer	Egy mutatót ad vissza a karakterekhez egy CSimpleStringT.
CSimpleStringT::GetBufferSetLength	Egy mutatót ad vissza a megadott hosszra csonkoló karakterekhez CSimpleStringT.
CSimpleStringT::GetLength	Egy objektum karaktereinek CSimpleStringT számát adja vissza.
CSimpleStringT::GetManager	Lekéri az objektum memóriakezelőjét CSimpleStringT .
CSimpleStringT::GetString	A karaktersztring lekérése
CSimpleStringT::IsEmpty	Azt ellenőrzi, hogy egy CSimpleStringT objektum nem tartalmaz-e karaktereket.
CSimpleStringT::LockBuffer	Letiltja a hivatkozásszámlálást, és védi a sztringet a pufferben.
CSimpleStringT::Preallocate	Meghatározott mennyiségű memóriát foglal le a karakterpufferhez.
CSimpleStringT::ReleaseBuffer	Felszabadítja a puffer által visszaadott vezérlőt GetBuffer.
CSimpleStringT::ReleaseBufferSetLength	Felszabadítja a puffer által visszaadott vezérlőt GetBuffer.
CSimpleStringT::SetAt	Egy karaktert egy adott pozícióba állít be.
CSimpleStringT::SetManager	Beállítja egy CSimpleStringT objektum memóriakezelőjét.
CSimpleStringT::SetString	Egy objektum sztringjének CSimpleStringT beállítása.
CSimpleStringT::StringLength	A megadott sztringben szereplő karakterek számát adja vissza.
CSimpleStringT::Truncate	Csonkolja a sztringet egy megadott hosszúságúra.
CSimpleStringT::UnlockBuffer	Engedélyezi a hivatkozásszámlálást, és felszabadítja a sztringet a pufferben.

Nyilvános operátorok

Név	Leírás
CSimpleStringT::operator PCXSTR	Az objektumban CSimpleStringT tárolt karaktereket közvetlenül C stílusú sztringként érheti el.
CSimpleStringT::operator[]	Egy adott pozícióban lévő karaktert ad vissza – operátorhelyettesítés a következőhöz GetAt: .
CSimpleStringT::operator +=	Egy meglévő sztring végéhez fűz egy új sztringet.
CSimpleStringT::operator =	Új értéket rendel egy CSimpleStringT objektumhoz.

Megjegyzések

CSimpleStringT a Visual C++ által támogatott különböző sztringosztályok alaposztálya. Minimális támogatást nyújt a sztringobjektum memóriakezeléséhez és az alapvető pufferkezeléshez. További speciális sztringobjektumok CStringT Class: .

Követelmények

fejléc:atlsimpstr.h

CSimpleStringT::Append

Objektum hozzáfűzése CSimpleStringT egy meglévő CSimpleStringT objektumhoz.

Szemantika

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

Paraméterek

strSrc
A CSimpleStringT hozzáfűzendő objektum.

pszSrc
Mutató a hozzáfűzendő karaktereket tartalmazó sztringre.

nLength
A hozzáfűzendő karakterek száma.

Megjegyzések

Hívja meg ezt a metódust, ha egy meglévő CSimpleStringT objektumot hozzáfűz egy másik CSimpleStringT objektumhoz.

példa

Az alábbi példa bemutatja a CSimpleStringT::Append használatát.

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

Egy karakter hozzáfűzése egy meglévő CSimpleStringT objektumhoz.

Szemantika

void AppendChar(XCHAR ch);

Paraméterek

ch
A hozzáfűzendő karakter

Megjegyzések

A függvény meghívásával fűzze hozzá a megadott karaktert egy meglévő CSimpleStringT objektum végéhez.

CSimpleStringT::CopyChars

Karaktert vagy karaktert másol egy CSimpleStringT objektumba.

Szemantika

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

Paraméterek

pchDest
Egy karaktersztringre mutató mutató.

nDestLen
Puffer mérete pchDest

pchSrc
A másolandó karaktereket tartalmazó sztringre mutató mutató.

nChars
A másolandó karakterek száma pchSrc .

Megjegyzések

Hívja meg ezt a metódust, hogy karaktereket pchSrc másoljon a sztringbe pchDest .

példa

Az alábbi példa bemutatja a CSimpleStringT::CopyChars használatát.

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

A példa kimenete a következő:

xxxxxxxxxxxxxxxxxxx
Hello world!xxxxxxx

CSimpleStringT::CopyCharsOverlapped

Karaktert vagy karaktert másol egy CSimpleStringT objektumba.

Szemantika

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

Paraméterek

pchDest
Egy karaktersztringre mutató mutató.

pchSrc
A másolandó karaktereket tartalmazó sztringre mutató mutató.

nChars
A másolandó karakterek száma pchSrc .

Megjegyzések

Hívja meg ezt a metódust, hogy karaktereket pchSrc másoljon a sztringbe pchDest . Ellentétben CopyCharsa karakterpufferek CopyCharsOverlapped másolásának biztonságos módszerével, amely átfedésben lehet.

példa

Lásd a példát CSimpleStringT::CopyChars, vagy a forráskódot CSimpleStringT::SetString (itt található atlsimpstr.h).

CSimpleStringT::CSimpleStringT

Egy CSimpleStringT objektumot hoz létre.

Szemantika

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

Paraméterek

strSrc
Az objektumba CSimpleStringT másolandó meglévő CSimpleStringT objektum.

pchSrc
Egy hosszú, nem null értékű karaktertömbre nLengthmutató mutató.

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

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

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

Megjegyzések

Hozzon létre egy új CSimpleStringT objektumot. Mivel a konstruktorok a bemeneti adatokat új lefoglalt tárolóba másolják, memóriakivételek következhetnek be.

példa

Az alábbi példa az ATL CSimpleStringT::CSimpleStringTtypedefhasználatával szemlélteti CSimpleString a használatát. CSimpleString az osztálysablon CSimpleStringTgyakran használt specializációja.

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

Az CSimpleStringT objektumot üres sztringként állítja be, és szükség szerint felszabadítja a memóriát.

Szemantika

void Empty() throw();

Megjegyzések

További információ : Sztringek: CString Kivétel törlése.

példa

Az alábbi példa bemutatja a CSimpleStringT::Empty használatát.

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

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

CSimpleStringT::FreeExtra

Felszabadítja a sztring által korábban lefoglalt, de már nem szükséges memóriát.

Szemantika

void FreeExtra();

Megjegyzések

Ez csökkenti a sztringobjektum által felhasznált memóriaterhelést. A metódus a puffert a visszaadott GetLengthpontos hosszra helyezi át.

példa

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

A példa kimenete a következő:

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

Lekéri egy objektum lefoglalt hosszát CSimpleStringT .

Szemantika

int GetAllocLength() const throw();

Visszaadott érték

Az objektumhoz lefoglalt karakterek száma.

Megjegyzések

Hívja meg ezt a metódust az objektumhoz lefoglalt karakterek számának meghatározásához CSimpleStringT . Tekintse meg FreeExtra a függvény meghívására szolgáló példát.

CSimpleStringT::GetAt

Egy karaktert ad vissza egy CSimpleStringT objektumból.

Szemantika

XCHAR GetAt(int iChar) const;

Paraméterek

iChar
Az objektum karakterének nulla alapú indexe CSimpleStringT . A iChar paraméternek 0-nál nagyobbnak vagy egyenlőnek kell lennie, és kisebbnek kell lennie, mint a visszaadott GetLengthérték. GetAt Ellenkező esetben kivételt hoz létre.

Visszaadott érték

Olyan XCHAR karakter, amely a sztring megadott helyén található karaktert tartalmazza.

Megjegyzések

Hívja meg ezt a metódust a megadott iCharkarakter visszaadásához. A túlterhelt alsó index ([]) operátor a .GetAt A null terminátor a kivétel létrehozása nélkül kezelhető a használatával GetAt. A függvény azonban nem számolja GetLength, és a visszaadott érték 0.

példa

Az alábbi példa bemutatja a használat módját CSimpleStringT::GetAt.

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

CSimpleStringT::GetBuffer

Egy mutatót ad vissza az objektum belső karakterpufferéhez CSimpleStringT .

Szemantika

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

Paraméterek

nMinBufferLength
A karakterpuffer által tartható karakterek minimális száma. Ez az érték nem tartalmaz szóközt null terminátorhoz.

Ha nMinBufferLength nagyobb, mint az aktuális puffer hossza, megsemmisíti az aktuális puffert, GetBuffer lecseréli a kért méretű pufferre, és nullára állítja vissza az objektumhivatkozások számát. Ha korábban már felhívta LockBuffer ezt a puffert, elveszíti a pufferzárat.

Visszaadott érték

Mutató PXSTR az objektum (null értékű) karakterpufferéhez.

Megjegyzések

Hívja meg ezt a metódust az objektum puffertartalmának visszaadásához CSimpleStringT . A visszaadott PXSTR érték nem állandó, ezért lehetővé teszi a CSimpleStringT tartalom közvetlen módosítását.

Ha a visszaadott mutatót használja a sztring GetBuffer tartalmának módosításához, más metódusok használata ReleaseBuffer előtt meg kell hívnia CSimpleStringT a belső állapot frissítésétCSimpleStringT.

Előfordulhat, hogy a visszaadott GetBuffer cím érvénytelen a hívás után, ReleaseBuffer mert további CSimpleStringT műveletek okozhatják a CSimpleStringT puffer újraelosztását. Ha nem módosítja a puffer hosszát, a rendszer nem helyezi át újra a puffert CSimpleStringT.

A puffermemória automatikusan felszabadul, amikor az CSimpleStringT objektum megsemmisül.

Ha nyomon követi a sztring hosszát, ne fűzze hozzá a végződő null karaktert. A puffer felszabadításakor azonban meg kell adnia a végső sztring hosszát ReleaseBuffer. Ha null karaktert fűz hozzá, a hosszhoz -1 (alapértelmezett) értéket kell megadnia. ReleaseBuffer majd meghatározza a puffer hosszát.

Ha nincs elegendő memória a kérés teljesítéséhez, ez a GetBuffer metódus egy CMemoryException*.

példa

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

Az objektum belső karakterpufferére CSimpleStringT mutató mutatót ad vissza, amely csonkolja vagy megnövekszik, ha szükséges, hogy pontosan egyezzen a megadott hosszúságsal nLength.

Szemantika

PXSTR GetBufferSetLength(int nLength);

Paraméterek

nLength
A karakterpuffer pontos mérete CSimpleStringT karakterekben.

Visszaadott érték

Mutató PXSTR az objektum (null értékű) karakterpufferéhez.

Megjegyzések

Hívja meg ezt a metódust az objektum belső pufferének megadott hosszának lekéréséhez CSimpleStringT . A visszaadott PXSTR mutató nem const , így lehetővé teszi a CSimpleStringT tartalom közvetlen módosítását.

Ha a visszaadott mutatóval módosítja a sztring GetBufferSetLength tartalmát, hívja meg ReleaseBuffer a belső állapot frissítését CSimpleStringT , mielőtt bármilyen más CSimpleStringT metódust használ.

Előfordulhat, hogy a visszaadott GetBufferSetLength cím érvénytelen a hívás után, ReleaseBuffer mert további CSimpleStringT műveletek okozhatják a CSimpleStringT puffer újraelosztását. Ha nem módosítja a puffer hosszát, a rendszer nem rendeli újra a puffert CSimpleStringT.

A puffermemória automatikusan felszabadul, amikor az CSimpleStringT objektum megsemmisül.

Ha a sztring hosszát saját maga követi nyomon, ne fűzze hozzá a végződő null karaktert. A puffer felszabadításakor meg kell adnia a végső sztring hosszát a használatával ReleaseBuffer. Ha a híváskor ReleaseBufferhozzáfűz egy végződő null karaktert, adja meg a -1 (alapértelmezett) értéket a hosszához ReleaseBuffer, és ReleaseBuffer a pufferen hajt végre egy strlen műveletet a hosszának meghatározásához.

A hivatkozásszámlálással kapcsolatos további információkért tekintse meg az alábbi cikkeket:

• Objektumélettartamok kezelése hivatkozásszámlálással a Windows SDK-ban.
• Referenciaszámlálás implementálása a Windows SDK-ban.
• A Referenciaszám kezelése a Windows SDK-ban.

példa

Az alábbi példa bemutatja a CSimpleStringT::GetBufferSetLength használatát.

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

Az objektumban lévő CSimpleStringT karakterek számát adja vissza.

Szemantika

int GetLength() const throw();

Visszaadott érték

A sztringben szereplő karakterek száma.

Megjegyzések

Hívja meg ezt a metódust az objektumban lévő karakterek számának visszaadásához. A darabszám nem tartalmaz null terminátort.

Többbájtos karakterkészletek (MBCS) GetLength esetén minden 8 bites karaktert megszámol, vagyis egy többbájtos karakterben lévő érdeklődő- és nyomvonal-bájtok két bájtnak számítanak. Tekintse meg FreeExtra a függvény meghívására szolgáló példát.

CSimpleStringT::GetManager

Lekéri az objektum memóriakezelőjét CSimpleStringT .

Szemantika

IAtlStringMgr* GetManager() const throw();

Visszaadott érték

Az objektum memóriakezelőjének CSimpleStringT mutatója.

Megjegyzések

Hívja meg ezt a metódust az objektum által használt memóriakezelő lekéréséhez CSimpleStringT . További információ a memóriakezelőkről és a sztringobjektumokról: Memóriakezelés és CStringT.

CSimpleStringT::GetString

Lekéri a karaktersztringet.

Szemantika

PCXSTR GetString() const throw();

Visszaadott érték

Egy null értékű karaktersztringre mutató mutató.

Megjegyzések

Hívja meg ezt a metódust az objektumhoz társított karaktersztring lekéréséhez CSimpleStringT .

Megjegyzés:

A visszaadott PCXSTR mutató nem const teszi lehetővé a CSimpleStringT tartalom közvetlen módosítását.

példa

Az alábbi példa bemutatja a CSimpleStringT::GetString használatát.

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

A példa kimenete a következő:

Cup soccer is best!

CSimpleStringT::IsEmpty

CSimpleStringT Egy objektumot tesztel az üres feltételhez.

Szemantika

bool IsEmpty() const throw();

Visszaadott érték

Akkor adja TRUE vissza, ha az CSimpleStringT objektum hossza 0, ellenkező esetben FALSE.

Megjegyzések

Hívja meg ezt a metódust annak megállapításához, hogy az objektum tartalmaz-e üres sztringet.

példa

Az alábbi példa bemutatja a CSimpleStringT::IsEmpty használatát.

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

CSimpleStringT::LockBuffer

Letiltja a hivatkozásszámlálást, és védi a sztringet a pufferben.

Szemantika

PXSTR LockBuffer();

Visszaadott érték

Mutató egy CSimpleStringT objektumra vagy egy null értékű sztringre.

Megjegyzések

Hívja meg ezt a metódust az objektum pufferének zárolásához CSimpleStringT . A hívással LockBufferlétre kell hoznia a sztring egy példányát, és egy -1 a hivatkozásszámhoz. Ha a referenciaszám értéke -1, a pufferben lévő sztring "zárolt" állapotúnak minősül. Zárolt állapotban a sztring kétféleképpen védett:

• A zárolt sztringben lévő adatokra semmilyen más sztring nem tud hivatkozni, még akkor sem, ha az adott sztring a zárolt sztringhez van rendelve.

• A zárolt sztring soha nem hivatkozik egy másik sztringre, még akkor sem, ha a másik sztringet a zárolt sztringbe másolja.

A pufferben lévő sztring zárolásával győződjön meg arról, hogy a sztring kizárólagos visszatartása a pufferen érintetlen marad.

Ha végzett a művelettel LockBuffer, hívja meg UnlockBuffer , hogy állítsa vissza a hivatkozás számát 1-re.

Megjegyzés:

Ha zárolt puffert hív meg GetBuffer , és a GetBuffer paramétert nMinBufferLength az aktuális puffer hosszánál nagyobbra állítja be, a pufferzár elveszik. Egy ilyen hívás GetBuffer megsemmisíti az aktuális puffert, lecseréli a kért méretű pufferre, és nullára állítja vissza a hivatkozásszámot.

A hivatkozásszámlálással kapcsolatos további információkért tekintse meg az alábbi cikkeket:

• Objektumélettartamok kezelése hivatkozásszámlálással a Windows SDK-ban

• Referenciaszámlálás implementálása a Windows SDK-ban

• A Referenciaszám kezelésének szabályai a Windows SDK-ban

példa

Az alábbi példa bemutatja a CSimpleStringT::LockBuffer használatát.

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

A példa kimenete a következő:

l

CSimpleStringT::operator[]

Hívja meg ezt a függvényt a karaktertömb egyetlen karakterének eléréséhez.

Szemantika

XCHAR operator[](int iChar) const;

Paraméterek

iChar
A sztring egyik karakterének nullaalapú indexe.

Megjegyzések

A túlterhelt alsó index ([]) operátor egyetlen karaktert ad vissza, amelyet a nulla alapú index határoz meg a következőben iChar: . Ez az operátor kényelmes helyettesítője a GetAt tagfüggvénynek.

Megjegyzés:

Az alsó index ([]) operátorral lekérheti egy karakter értékét egy CSimpleStringTadott karakterben, de egy karakter CSimpleStringTértékét nem módosíthatja.

példa

Az alábbi példa bemutatja a CSimpleStringT::operator [] használatát.

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

CSimpleStringT::operator +=

Új sztringet vagy karaktert illeszt egy meglévő sztring végéhez.

Szemantika

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

Paraméterek

pszSrc
Egy null értékű sztringre mutató mutató.

strSrc
Egy meglévő CSimpleStringT objektumra mutató mutató.

ch
A hozzáfűzendő karakter.

Megjegyzések

Az operátor egy másik CSimpleStringT objektumot vagy karaktert fogad el. Vegye figyelembe, hogy a memóriakivételek akkor fordulhatnak elő, amikor ezt az összefűzési operátort használja, mert az objektumhoz hozzáadott karakterek számára új tárterületet lehet lefoglalni CSimpleStringT .

példa

Az alábbi példa bemutatja a CSimpleStringT::operator += használatát.

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

CSimpleStringT::operator =

Új értéket rendel egy CSimpleStringT objektumhoz.

Szemantika

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

Paraméterek

pszSrc
Egy null értékű sztringre mutató mutató.

strSrc
Egy meglévő CSimpleStringT objektumra mutató mutató.

Megjegyzések

Ha a célsztring (a bal oldali) már elég nagy az új adatok tárolásához, nem történik új memóriafoglalás. Vegye figyelembe, hogy memóriakivételek akkor fordulhatnak elő, amikor a hozzárendelési operátort használja, mert az új tárterületet gyakran lefoglalják az eredményként kapott CSimpleStringT objektum tárolására.

példa

Az alábbi példa bemutatja a CSimpleStringT::operator = használatát.

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

Az objektumban CSimpleStringT tárolt karaktereket közvetlenül C stílusú sztringként érheti el.

Szemantika

operator PCXSTR() const throw();

Visszaadott érték

Egy karaktermutató a sztring adataira.

Megjegyzések

A program nem másol karaktereket; csak egy mutatót ad vissza. Legyen óvatos ezzel az operátorral. Ha a karaktermutató beszerzése után módosít egy CString objektumot, a memória olyan újrakiosztását okozhatja, amely érvényteleníti a mutatót.

példa

Az alábbi példa bemutatja a CSimpleStringT::operator PCXSTR használatát.

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

Egy állandó sztringre mutató mutató.

Szemantika

typedef ChTraitsBase< BaseType >::PCXSTR PCXSTR;

CSimpleStringT::Preallocate

Meghatározott mennyiségű bájtot foglal le az CSimpleStringT objektumhoz.

Szemantika

void Preallocate( int nLength);

Paraméterek

nLength
A karakterpuffer pontos mérete CSimpleStringT karakterekben.

Megjegyzések

Ennek a metódusnak a meghívásával lefoglalhat egy adott pufferméretet az CSimpleStringT objektumhoz.

CSimpleStringT Kivételt STATUS_NO_MEMORY hoz létre, ha nem tud helyet lefoglalni a karakterpuffer számára. A memóriafoglalást alapértelmezés szerint a WIN32 API-függvények HeapAlloc vagy HeapReAlloca .

példa

Az alábbi példa bemutatja a CSimpleStringT::Preallocate használatát.

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

A példa kimenete a következő:

Allocated length: 0
Allocated length: 103

CSimpleStringT::PXSTR

Mutató egy sztringre.

Szemantika

typedef ChTraitsBase< BaseType >::PXSTR PXSTR;

CSimpleStringT::ReleaseBuffer

Felszabadítja a rendszer által lefoglalt puffer vezérlését GetBuffer.

Szemantika

void ReleaseBuffer(int nNewLength = -1);

Paraméterek

nNewLength
A sztring új hossza karakterekben, null terminátort nem számolva. Ha a sztring null értékű, az -1 alapértelmezett érték a CSimpleStringT sztring aktuális hosszára állítja a méretet.

Megjegyzések

Hívja meg ezt a metódust a sztringobjektum pufferének újraelosztásához vagy felszabadításához. Ha tudja, hogy a pufferben lévő sztring null értékű, kihagyhatja az argumentumot nNewLength . Ha a sztring nem null értékű, adja nNewLength meg a hosszát. A visszaadott GetBuffer cím érvénytelen a hívás ReleaseBuffer vagy bármely más CSimpleStringT művelet után.

példa

Az alábbi példa bemutatja a CSimpleStringT::ReleaseBuffer használatát.

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

Felszabadítja a rendszer által lefoglalt puffer vezérlését GetBuffer.

Szemantika

void ReleaseBufferSetLength(int nNewLength);

Paraméterek

nNewLength
A feloldott sztring hossza

Megjegyzések

Ez a függvény funkcionálisan hasonlít a ReleaseBuffer sztringobjektum érvényes hosszának átadására.

CSimpleStringT::SetAt

Egyetlen karaktert állít be egy CSimpleStringT objektumból.

Szemantika

void SetAt(int iChar, XCHAR ch);

Paraméterek

iChar
Az objektum karakterének nulla alapú indexe CSimpleStringT . A iChar paraméternek 0-nál nagyobbnak vagy egyenlőnek kell lennie, és kisebbnek kell lennie, mint a visszaadott GetLengthérték.

ch
Az új karakter.

Megjegyzések

A metódus meghívásával felülírhatja a következő helyen található karaktert iChar: . Ez a metódus nem növeli a sztringet, ha iChar meghaladja a meglévő sztring határait.

példa

Az alábbi példa bemutatja a CSimpleStringT::SetAt használatát.

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

CSimpleStringT::SetManager

Az objektum memóriakezelőjét CSimpleStringT adja meg.

Szemantika

void SetManager(IAtlStringMgr* pStringMgr);

Paraméterek

pStringMgr
Mutató az új memóriakezelőhöz.

Megjegyzések

Hívja meg ezt a metódust az objektum által használt új memóriakezelő megadásához CSimpleStringT . További információ a memóriakezelőkről és a sztringobjektumokról: Memóriakezelés és CStringT.

példa

Az alábbi példa bemutatja a CSimpleStringT::SetManager használatát.

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

CSimpleStringT::SetString

Egy objektum sztringjének CSimpleStringT beállítása.

Szemantika

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

Paraméterek

pszSrc
Egy null értékű sztringre mutató mutató.

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

Megjegyzések

Sztring másolása az CSimpleStringT objektumba. SetString felülírja a puffer régebbi sztringadatait.

Mindkét verzió ellenőrzi SetString , hogy null mutató-e pszSrc , és ha igen, hibát jelez E_INVALIDARG .

Az egyparaméteres verzió SetString null értékű sztringre fog pszSrc mutatni.

A kétparaméteres verzió SetString szintén null értékű sztringre számít pszSrc . Sztringhosszként használja nLength , kivéve, ha először null terminátorsal találkozik.

A kétparaméteres verzió SetString azt is ellenőrzi, hogy az aktuális puffer egy helyére mutat-epszSrc.CSimpleStringT Ebben a speciális esetben egy memóriamásolási függvényt használ, SetString amely nem írja felül a sztringadatokat, miközben a sztringadatokat visszamásolja a pufferbe.

példa

Az alábbi példa bemutatja a CSimpleStringT::SetString használatát.

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

CSimpleStringT::StringLength

A megadott sztringben szereplő karakterek számát adja vissza.

Szemantika

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

Paraméterek

psz
Egy null értékű sztringre mutató mutató.

Visszaadott érték

A karakterek száma a következőben psz: ; null terminátort nem számol.

Megjegyzések

Ennek a metódusnak a meghívásával lekérheti a sztringben pszszereplő karakterek számát.

példa

Az alábbi példa bemutatja a CSimpleStringT::StringLength használatát.

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

CSimpleStringT::Truncate

Csonkolja a sztringet az új hosszra.

Szemantika

void Truncate(int nNewLength);

Paraméterek

nNewLength
A sztring új hossza.

Megjegyzések

Ennek a metódusnak a meghívásával csonkíthatja a sztring tartalmát az új hosszra.

Megjegyzés:

Ez nem befolyásolja a puffer lefoglalt hosszát. Az aktuális puffer csökkentéséhez vagy növeléséhez lásd FreeExtra és Preallocate.

példa

Az alábbi példa bemutatja a CSimpleStringT::Truncate használatát.

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

A példában szereplő kimenet a következő:

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

CSimpleStringT::UnlockBuffer

Feloldja az objektum pufferét CSimpleStringT .

Szemantika

void UnlockBuffer() throw();

Megjegyzések

A metódus meghívásával állítsa vissza a sztring hivatkozási számát 1-re.

A CSimpleStringT destruktor automatikusan meghívja UnlockBuffer , hogy a puffer ne legyen zárolva a destruktor meghívásakor. Erre a módszerre példa: LockBuffer.

CSimpleStringT::~CSimpleStringT

Elpusztít egy objektumot CSimpleStringT .

Szemantika

~CSimpleStringT() throw();

Megjegyzések

Hívja meg ezt a metódust az CSimpleStringT objektum elpusztításához.

Lásd még

hierarchiadiagram
ATL/MFC megosztott osztályok