CStringT-klass

Den här klassen representerar ett CStringT objekt.

Syntax

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

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

StringTraits
Avgör om strängklassen behöver stöd för C Run-Time-bibliotek (CRT) och var strängresurser finns. Kan vara något av följande:

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

  Klassen kräver CRT-stöd och söker efter resurssträngar i modulen som anges av m_hInstResource (en medlem i programmets modulklass).

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

  Klassen kräver inte CRT-stöd och söker efter resurssträngar i modulen som anges av m_hInstResource (en medlem i programmets modulklass).

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

  Klassen kräver CRT-stöd och söker efter resurssträngar med hjälp av MFC-standardsökalgoritmen.

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

  Klassen kräver inte CRT-stöd och söker efter resurssträngar med hjälp av MFC-standardsökalgoritmen.

Medlemmar

Offentliga konstruktorer

Offentliga metoder

Operatörer

Anmärkningar

CStringT ärver från CSimpleStringT klass. Avancerade funktioner, till exempel teckenmanipulering, beställning och sökning, implementeras av CStringT.

Ett CStringT objekt består av en sekvens med tecken med variabel längd. CStringT innehåller funktioner och operatorer som använder syntax som liknar den i Basic. Sammanfognings- och jämförelseoperatorer, tillsammans med förenklad minneshantering, gör CStringT objekt enklare att använda än vanliga teckenmatriser.

Genom att använda olika kombinationer av parametrarna BaseTypeStringTraits och CStringT kan objekt komma i följande typer, som har fördefinierade av ATL-biblioteken.

Om du använder i ett ATL-program:

CString, CStringAoch CStringW exporteras från MFC DLL (MFC90.DLL), aldrig från användar-DLL:er. Detta görs för att förhindra CStringT att definieras flera gånger.

Följande strängtyper är tillgängliga i MFC-baserade program:

Följande strängtyper är tillgängliga i projekt där ATL_CSTRING_NO_CRT definieras:

Följande strängtyper är tillgängliga i projekt där ATL_CSTRING_NO_CRT inte har definierats:

CString objekt har också följande egenskaper:

• CStringT objekt kan växa på grund av sammanfogningsåtgärder.

• CStringT objekt följer "värdesemantik". Tänk på ett CStringT objekt som en faktisk sträng, inte som en pekare till en sträng.

• Du kan fritt ersätta CStringT objekt med PCXSTR funktionsargument.

• Anpassad minneshantering för strängbuffertar. Mer information finns i Minneshantering och CStringT.

Fördefinierade CStringT-typer

Eftersom CStringT använder ett mallargument för att definiera teckentypen (antingen wchar_t eller char) som stöds kan metodparametertyper vara komplicerade ibland. För att förenkla det här problemet definieras och används en uppsättning fördefinierade typer i hela CStringT klassen. I följande tabell visas de olika typerna:

Arvshierarki

CSimpleStringT

CStringT

Kravspecifikation

CStringT::AllocSysString

Allokerar en Automation-kompatibel sträng av typen BSTR och kopierar innehållet i CStringT objektet till det, inklusive det avslutande null-tecknet.

BSTR AllocSysString() const;

Returvärde

Den nyligen allokerade strängen.

Anmärkningar

I MFC-program utlöses en CMemoryException klass om det inte finns tillräckligt med minne. I ATL-program utlöses en CAtlException . Den här funktionen används normalt för att returnera strängar för Automation.

Om den här strängen skickas till en COM-funktion som en [in] parameter kräver det ofta att anroparen frigör strängen. Detta kan göras med hjälp SysFreeStringav , enligt beskrivningen i Windows SDK. Mer information finns i Allokera och frigöra minne för en BSTR.

Mer information om OLE-allokeringsfunktioner i Windows SysAllocString finns i Windows SDK.

Exempel

I följande exempel visas användningen av CStringT::AllocSysString.

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString str(_T("This is a test string!"));
BSTR bstr = str.AllocSysString();

// bstr now contains "This is a test string!", and can be
// passed to any OLE function requiring a BSTR.
// Normally, if you pass the BSTR, you will
// need to free the string after returning from the function call.   

CStringT::AnsiToOem

Konverterar alla tecken i det här CStringT objektet från ANSI-teckenuppsättningen till OEM-teckenuppsättningen.

void AnsiToOem();

Anmärkningar

Funktionen är inte tillgänglig om _UNICODE den har definierats.

Exempel

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

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

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

CStringT::AppendFormat

Lägger till formaterade data i ett befintligt CStringT objekt.

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

Parameterar

pszFormat
En formatkontrollsträng.

nFormatID
Strängresursidentifieraren som innehåller formatkontrollsträngen.

argument
Valfria argument.

Anmärkningar

Den här funktionen formaterar och lägger till en serie tecken och värden i CStringT. Varje valfritt argument (om det finns) konverteras och läggs till enligt motsvarande formatspecifikation i pszFormat eller från strängresursen som identifieras av nFormatID.

Exempel

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

CAtlString str = _T("Some data:\t");

str.AppendFormat(_T("X value = %.2f\n"), 12345.12345);
_tprintf_s(_T("%s"), (LPCTSTR) str);

CStringT::Collate

Jämför två strängar med funktionen _tcscollgeneric-text .

int Collate(PCXSTR psz) const throw();

Parameterar

psz
Den andra strängen som används för jämförelse.

Returvärde

Noll om strängarna är identiska, < 0 om det här CStringT objektet är mindre än psz, eller > 0 om det här CStringT objektet är större än psz.

Anmärkningar

Funktionen _tcscollgeneric-text , som definieras i TCHAR.H, mappar till antingen strcoll, wcscolleller _mbscoll, beroende på den teckenuppsättning som definieras vid kompileringstiden. Varje funktion gör en skiftlägeskänslig jämförelse av strängarna enligt den kodsida som för närvarande används. Mer information finns i strcoll, , wcscoll_mbscoll, _strcoll_l, , _wcscoll_l_mbscoll_l.

CStringT::CollateNoCase

Jämför två strängar med funktionen _tcscollgeneric-text .

int CollateNoCase(PCXSTR psz) const throw();

Parameterar

psz
Den andra strängen som används för jämförelse.

Returvärde

Noll om strängarna är identiska (ignorerar skiftläge), < 0 om det här CStringT objektet är mindre än psz (ignorerar skiftläge) eller > 0 om det här CStringT objektet är större än psz (ignorerar skiftläge).

Anmärkningar

Funktionen _tcscollgeneric-text , som definieras i TCHAR.H, mappar till antingen stricoll, wcsicolleller _mbsicoll, beroende på den teckenuppsättning som definieras vid kompileringstiden. Varje funktion gör en skiftlägeskänslig jämförelse av strängarna, enligt den kodsida som för närvarande används. Mer information finns i strcoll, wcscoll, _mbscoll, _strcoll_l, , _wcscoll_l. _mbscoll_l

Exempel

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

CAtlString str1 = _T("Co-Op");
CAtlString str2 = _T("con");

int n;

// Collation uses language rules, such as ignoring dashes.
// NoCase version ignores case.
n = str1.CollateNoCase(str2);
ASSERT(n < 0);

// Comparison is a strict ASCII comparison with no language rules
// but still ignores case in NoCase version.
n = str1.CompareNoCase(str2);
ASSERT(n < 0);   

CStringT::Compare

Jämför två strängar (skiftlägeskänsliga).

int Compare(PCXSTR psz) const;

Parameterar

psz
Den andra strängen som används för jämförelse.

Returvärde

Noll om strängarna är identiska, < 0 om det här CStringT objektet är mindre än psz, eller > 0 om det här CStringT objektet är större än psz.

Anmärkningar

Funktionen _tcscmpgeneric-text , som definieras i TCHAR.H, mappar till antingen strcmp, wcscmpeller _mbscmp, beroende på den teckenuppsättning som definieras vid kompileringstiden. Varje funktion gör en skiftlägeskänslig jämförelse av strängarna och påverkas inte av nationella inställningar. Mer information finns i strcmp, wcscmp, _mbscmp.

Om strängen innehåller inbäddade null-värden anses strängen trunkeras vid det första inbäddade null-tecknet i jämförelsesyfte.

Exempel

I följande exempel visas användningen av CStringT::Compare.

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

CAtlString s1(_T("abc"));
CAtlString s2(_T("abd"));
ASSERT(s1.Compare(s2) < 0);    // Compare with another CAtlString.
ASSERT(s1.Compare(_T("abe")) < 0); // Compare with LPTSTR string.   

CStringT::CompareNoCase

Jämför två strängar (skiftlägesokänsliga).

int CompareNoCase(PCXSTR psz) const throw();

Parameterar

psz
Den andra strängen som används för jämförelse.

Returvärde

Noll om strängarna är identiska (ignorerar skiftläge), <0 om det här CStringT objektet är mindre än psz (ignorerar skiftläge) eller >0 om det här CStringT objektet är större än psz (ignorerar skiftläge).

Anmärkningar

Funktionen _tcsicmpgeneric-text , som definieras i TCHAR.H, mappar till antingen _stricmp, _wcsicmp eller _mbsicmp, beroende på den teckenuppsättning som definieras vid kompileringstiden. Varje funktion gör en skiftlägeskänslig jämförelse av strängarna. Jämförelsen beror på aspekten LC_CTYPE av nationella inställningar men inte LC_COLLATE. Mer information finns i _stricmp, _wcsicmp, _mbsicmp, _stricmp_l, , _wcsicmp_l. _mbsicmp_l

Exempel

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

CAtlString s1(_T("abc"));
CAtlString s2(_T("ABD"));
ASSERT(s1.CompareNoCase(s2) < 0); // Compare with a CAtlString.
ASSERT(s1.CompareNoCase(_T("ABE")) < 0); // Compare with LPTSTR string.   

CStringT::CStringT

Konstruerar ett CStringT objekt.

CStringT() throw() :
    CThisSimpleString(StringTraits::GetDefaultManager());

explicit CStringT(IAtlStringMgr* pStringMgr) throw() :
    CThisSimpleString( pStringMgr);

CStringT(const VARIANT& varSrc);

CStringT(const VARIANT& varSrc, IAtlStringMgr* pStringMgr);

CStringT(const CStringT& strSrc) :
    CThisSimpleString( strSrc);

operator CSimpleStringT<
                    BaseType,
                    !_CSTRING_IMPL_::_MFCDLLTraitsCheck<BaseType, StringTraits>
                    :: c_bIsMFCDLLTraits> &()

template <bool bMFCDLL>
CStringT(const CSimpleStringT<BaseType, bMFCDLL>& strSrc) :
    CThisSimpleString( strSrc);

template <class SystemString>
CStringT(SystemString^ pString) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(const XCHAR* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CSTRING_EXPLICIT CStringT(const YCHAR* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(LPCSTR pszSrc, IAtlStringMgr* pStringMgr) :
    CThisSimpleString( pStringMgr);

CStringT(LPCWSTR pszSrc, IAtlStringMgr* pStringMgr) :
    CThisSimpleString( pStringMgr);

CSTRING_EXPLICIT CStringT(const unsigned char* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

/*CSTRING_EXPLICIT*/ CStringT(char* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CSTRING_EXPLICIT CStringT(unsigned char* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CSTRING_EXPLICIT CStringT(wchar_t* pszSrc) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(const unsigned char* pszSrc, IAtlStringMgr* pStringMgr) :
    CThisSimpleString( pStringMgr);

CSTRING_EXPLICIT CStringT(char ch, int nLength = 1) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CSTRING_EXPLICIT CStringT(wchar_t ch, int nLength = 1) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(const XCHAR* pch, int nLength) :
    CThisSimpleString( pch, nLength, StringTraits::GetDefaultManager());

CStringT(const YCHAR* pch, int nLength) :
    CThisSimpleString( StringTraits::GetDefaultManager());

CStringT(const XCHAR* pch, int nLength, AtlStringMgr* pStringMgr) :
    CThisSimpleString( pch, nLength, pStringMgr);

CStringT(const YCHAR* pch, int nLength, IAtlStringMgr* pStringMgr) :
    CThisSimpleString( pStringMgr);

Parameterar

pch
En pekare till en matris med tecken med längd nLength, inte null-avslutad.

nLength
Antal tecken i pch.

ch
Ett enda tecken.

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

pStringMgr
En pekare till minneshanteraren för CStringT objektet. Mer information om IAtlStringMgr och minneshantering för CStringTfinns i Minneshantering med CStringT.

strSrc
Ett befintligt CStringT objekt som ska kopieras till det här CStringT objektet. Mer information om CThisString och CThisSimpleStringfinns i avsnittet Anmärkningar.

varSrc
Ett variantobjekt som ska kopieras till det här CStringT objektet.

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

bMFCDLL
Booleskt värde som anger om projektet är en MFC DLL (TRUE) eller inte (FALSE).

SystemString
Måste vara System::String, och projektet måste kompileras med /clr.

pString
Ett handtag för ett CStringT objekt.

Anmärkningar

Eftersom konstruktorerna kopierar indata till ny allokerad lagring kan minnesfel uppstå. Vissa av dessa konstruktorer fungerar som konverteringsfunktioner. På så sätt kan du till exempel ersätta ett LPTSTR där ett CStringT objekt förväntas.

• CStringT(LPCSTRlpsz): Konstruerar en Unicode CStringT från en ANSI-sträng. Du kan också använda den här konstruktorn för att läsa in en strängresurs enligt exemplet nedan.

• CStringT(LPCWSTRlpsz): Konstruerar en CStringT från en Unicode-sträng.

• CStringT(const unsigned char*psz): Gör att du kan skapa en CStringT från en pekare till unsigned char.

Parametern strSrc kan vara antingen ett objekt eller CStringT ett CThisSimpleString objekt. För CStringTanvänder du någon av dess standard-instansieringar (CString, CStringA, eller CStringW); för CThisSimpleString, en this pekare. CThisSimpleString deklarerar en instans av CSimpleStringT klassen, som är en mindre strängklass med mindre inbyggda funktioner än CStringT klassen.

Överlagringsoperatorn CSimpleStringT<>&() konstruerar ett CStringT objekt från en CSimpleStringT deklaration.

Exempel

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

CAtlString s1;                    // Empty string
CAtlString s2(_T("cat"));           // From a C string literal
CAtlString s3 = s2;               // Copy constructor
CAtlString s4(s2 + _T(" ") + s3);   // From a string expression

CAtlString s5(_T('x'));             // s5 = "x"
CAtlString s6(_T('x'), 6);          // s6 = "xxxxxx"

CAtlString s7((LPCSTR)ID_FILE_NEW); // s7 = "Create a new document"

VARIANT var;
V_VT(&var) = VT_BSTR;
V_BSTR(&var) = ::SysAllocString(L"Football is a fun sport.");
CAtlString s8(var); // s8 = "Football is a fun sport."

// The following statement does not call the assignment operator.
// The compiler considers the following statement equivalent to
// CAtlString city("Paris")
CAtlString city = _T("Paris");   

CStringT::~CStringT

Förstör objektet CStringT .

~CStringT() throw();

Anmärkningar

Förstör objektet CStringT .

CStringT::Delete

Tar bort ett tecken eller tecken från en sträng som börjar med tecknet vid det angivna indexet.

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

Parameterar

iIndex
Det nollbaserade indexet för det första tecknet i objektet som CStringT ska tas bort.

nCount
Antalet tecken som ska tas bort.

Returvärde

Längden på den ändrade strängen.

Anmärkningar

Om nCount är längre än strängen tas resten av strängen bort.

Exempel

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

CAtlString str(_T("Soccer is best, but hockey is quicker!"));
_tprintf_s(_T("Before: %s\n"), (LPCTSTR)str);

int n = str.Delete(6, 3);
_tprintf_s(_T("After: %s\n"), (LPCTSTR)str);
ASSERT(n == str.GetLength());

Before: Soccer is best,
    but hockey is quicker!
After: Soccer best,
    but hockey is quicker!

CStringT::Find

Söker i den här strängen efter den första matchningen av ett tecken eller understräng.

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

Parameterar

pszSub
En delsträng att söka efter.

iStart
Indexet för tecknet i strängen för att påbörja sökningen med eller 0 för att starta från början.

ch
Ett enda tecken att söka efter.

Returvärde

Det nollbaserade indexet för det första tecknet i det här CStringT objektet som matchar den begärda delsträngen eller tecknen. -1 om delsträngen eller tecknet inte hittas.

Anmärkningar

Funktionen är överbelastad för att acceptera båda entecken (liknar körningsfunktionen strchr) och strängar (liknar strstr).

Exempel

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

CAtlString s(_T("abcdef"));
ASSERT(s.Find(_T('c')) == 2);
ASSERT(s.Find(_T("de")) == 3);

CAtlString str(_T("The waves are still"));
int n = str.Find(_T('e'), 5);
ASSERT(n == 7);   

CStringT::FindOneOf

Söker i den här strängen efter det första tecknet som matchar alla tecken i pszCharSet.

int FindOneOf(PCXSTR pszCharSet) const throw();

Parameterar

pszCharSet
Sträng som innehåller tecken för matchning.

Returvärde

Det nollbaserade indexet för det första tecknet i den här strängen som också finns i pszCharSet; -1 om det inte finns någon matchning.

Anmärkningar

Hittar den första förekomsten av något av tecknen i pszCharSet.

Exempel

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

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

CStringT::Format

Skriver formaterade data till en CStringT på samma sätt som sprintf_s formaterar data till en teckenmatris i C-stil.

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

Parameterar

nFormatID
Strängresursidentifieraren som innehåller formatkontrollsträngen.

pszFormat
En formatkontrollsträng.

argument
Valfria argument.

Anmärkningar

Den här funktionen formaterar och lagrar en serie tecken och värden i CStringT. Varje valfritt argument (om det finns) konverteras och utdata enligt motsvarande formatspecifikation i pszFormat eller från strängresursen som identifieras av nFormatID.

Anropet misslyckas om själva strängobjektet erbjuds som en parameter till Format. Följande kod orsakar till exempel oförutsägbara resultat:

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

Mer information finns i Syntax för formatspecifikation: printf och wprintf funktioner.

Exempel

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

str.Format(_T("Floating point: %.2f\n"), 12345.12345);
_tprintf_s(_T("%s"), (LPCTSTR) str);

str.Format(_T("Left-justified integer: %.6d\n"), 35);
_tprintf_s(_T("%s"), (LPCTSTR) str);

CStringT::FormatMessage

Formaterar en meddelandesträng.

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

Parameterar

nFormatID
Strängresursidentifieraren som innehåller den oformaterade meddelandetexten.

pszFormat
Pekar på formatkontrollsträngen. Den genomsöks efter infogningar och formateras därefter. Formatsträngen liknar run-time-formatsträngar i funktionsformat printf, förutom att parametrarna kan infogas i godtycklig ordning.

argument
Valfria argument.

Anmärkningar

Funktionen kräver en meddelandedefinition som indata. Meddelandedefinitionen bestäms av pszFormat eller från strängresursen som identifieras av nFormatID. Funktionen kopierar den formaterade meddelandetexten CStringT till objektet och bearbetar eventuella inbäddade infogningssekvenser om det begärs.

Varje infogning måste ha en motsvarande parameter som följer parametern pszFormat eller nFormatID . I meddelandetexten stöds flera escape-sekvenser för dynamisk formatering av meddelandet. Mer information finns i Windows-funktionen FormatMessage i Windows SDK.

Exempel

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

CAtlString str;
int nAsked = 5;
int nAgree = 4;

str.FormatMessage(_T("%1!d! of %2!d! writers agree: Soccer is %3%!"), 
   nAgree, nAsked, _T("Best"));
ASSERT(str == _T("4 of 5 writers agree: Soccer is Best!"));   

CStringT::FormatMessageV

Formaterar en meddelandesträng med hjälp av en variabelargumentlista.

void FormatMessageV(PCXSTR pszFormat, va_list* pArgList);

Parameterar

pszFormat
Pekar på formatkontrollsträngen. Den genomsöks efter infogningar och formateras därefter. Formatsträngen liknar run-time-formatsträngar i funktionsformat printf, förutom att parametrarna kan infogas i godtycklig ordning.

pArgList
Pekare till en lista med argument.

Anmärkningar

Funktionen kräver en meddelandedefinition som indata, som bestäms av pszFormat. Funktionen kopierar den formaterade meddelandetexten CStringT och en variabellista med argument till objektet och bearbetar eventuella inbäddade infogningssekvenser om det begärs.

Mer information finns i Windows-funktionen FormatMessage i Windows SDK.

CStringT::FormatV

Formaterar en meddelandesträng med hjälp av en variabelargumentlista.

void FormatV(PCXSTR pszFormat, va_list args);

Parameterar

pszFormat
Pekar på formatkontrollsträngen. Den genomsöks efter infogningar och formateras därefter. Formatsträngen liknar run-time-formatsträngar i funktionsformat printf, förutom att parametrarna kan infogas i godtycklig ordning.

args
Pekare till en lista med argument.

Anmärkningar

Skriver en formaterad sträng och en variabellista med argument till en CStringT sträng på samma sätt som vsprintf_s formaterar data till en teckenmatris i C-format.

Exempel

void WriteString(LPCTSTR pstrFormat, ...)
{
    CString str;

    // format and write the data you were given
    va_list args;
    va_start(args, pstrFormat);

    str.FormatV(pstrFormat, args);
    va_end(args);

    _tprintf_s(str);
    return;
}

// Call the above WriteString function.
WriteString(_T("%d error(s) found in %d line(s)"), 10, 1351);

CStringT::GetEnvironmentVariable

Anger strängen till värdet för den angivna miljövariabeln.

BOOL GetEnvironmentVariable(PCXSTR pszVar);

Parameterar

pszVar
Pekare till en null-avslutad sträng som anger miljövariabeln.

Returvärde

Nonzero om det lyckas; annars 0.

Anmärkningar

Hämtar värdet för den angivna variabeln från miljöblocket i anropsprocessen. Värdet är i form av en null-avslutad sträng med tecken.

Exempel

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

EnvStr.GetEnvironmentVariable(_T("TEMP"));
_tprintf_s(_T("Current value of TEMP variable: %s\n"), EnvStr);

CStringT::Insert

Infogar ett enskilt tecken eller en delsträng i det angivna indexet i strängen.

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

Parameterar

iIndex
Indexet för det tecken som insättningen ska äga rum före.

psz
En pekare till delsträngen som ska infogas.

ch
Det tecken som ska infogas.

Returvärde

Längden på den ändrade strängen.

Anmärkningar

Parametern iIndex identifierar det första tecknet som ska flyttas för att göra plats för tecknet eller delsträngen. Om nIndex är noll sker infogningen före hela strängen. Om nIndex är högre än längden på strängen sammanfogar funktionen den aktuella strängen och det nya materialet som tillhandahålls av antingen ch eller psz.

Exempel

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

CAtlString str(_T("SoccerBest"));
int n = str.Insert(6, _T("is "));
ASSERT(n == str.GetLength());
_tprintf_s(_T("1: %s\n"), (LPCTSTR) str);

n = str.Insert(6, _T(' '));
ASSERT(n == str.GetLength());
_tprintf_s(_T("2: %s\n"), (LPCTSTR) str);

n = str.Insert(55, _T('!'));
ASSERT(n == str.GetLength());
_tprintf_s(_T("3: %s\n"), (LPCTSTR) str);

CStringT::Left

Extraherar de vänstra nCount tecknen från det här CStringT objektet och returnerar en kopia av den extraherade delsträngen.

CStringT Left(int nCount) const;

Parameterar

nCount
Antalet tecken som ska extraheras från det här CStringT objektet.

Returvärde

Ett CStringT objekt som innehåller en kopia av det angivna teckenintervallet. Det returnerade CStringT objektet kan vara tomt.

Anmärkningar

Om nCount överskrider stränglängden extraheras hela strängen. Left liknar funktionen Basic Left .

För flerbytesteckenuppsättningar (MBCS) nCount behandlar varje 8-bitars sekvens som ett tecken, så att nCount returnerar antalet flerbytestecken multiplicerat med två.

Exempel

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

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

CStringT::LoadString

Läser en Windows-strängresurs, identifierad av nID, till ett befintligt CStringT objekt.

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

Parameterar

hInstance
En referens till modulens instans.

nID
Ett Windows-strängresurs-ID.

wLanguageID
Strängresursens språk.

Returvärde

Nonzero om resursbelastningen lyckades. annars 0.

Anmärkningar

Läser in strängresursen (nID) från den angivna modulen (hInstance) med det angivna språket (wLanguage).

Exempel

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

CAtlString s;
s.LoadString(IDS_APP_TITLE);   

CStringT::MakeLower

Konverterar objektet till en gemen CStringT sträng.

CStringT& MakeLower();

Returvärde

Den resulterande gemenersträngen.

Exempel

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

CAtlString s(_T("ABC"));

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

CStringT::MakeReverse

Ändrar ordningen på tecknen i CStringT objektet.

CStringT& MakeReverse();

Returvärde

Den resulterande omvända strängen.

Exempel

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

CAtlString s(_T("abc"));

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

CStringT::MakeUpper

Konverterar objektet CStringT till en versalsträng.

CStringT& MakeUpper();

Returvärde

Den resulterande versaler strängen.

Anmärkningar

Exempel

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

CAtlString s(_T("abc"));

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

CStringT::Mid

Extraherar en delsträng med längdtecken nCount från det här CStringT objektet med början vid position iFirst (nollbaserad).

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

Parameterar

iFirst
Det nollbaserade indexet för det första tecknet i det här CStringT objektet som ska ingå i den extraherade delsträngen.

nCount
Antalet tecken som ska extraheras från det här CStringT objektet. Om den här parametern inte anges extraheras resten av strängen.

Returvärde

Ett CStringT objekt som innehåller en kopia av det angivna teckenintervallet. Det returnerade CStringT objektet kan vara tomt.

Anmärkningar

Funktionen returnerar en kopia av den extraherade delsträngen. Mid liknar funktionen Basic Mid (förutom att index i Basic är enbaserade).

För flerbytesteckenuppsättningar (MBCS) nCount refererar till varje 8-bitars tecken, dvs. en lead- och trail-byte i ett flerbytestecken räknas som två tecken.

Exempel

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

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

CStringT::OemToAnsi

Konverterar alla tecken i det här CStringT objektet från OEM-teckenuppsättningen till ANSI-teckenuppsättningen.

void OemToAnsi();

Anmärkningar

Den här funktionen är inte tillgänglig om _UNICODE den har definierats.

Exempel

Se exemplet för CStringT::AnsiToOem.

CStringT::operator =

Tilldelar strängen ett nytt värde.

CStringT& operator=(const CStringT& strSrc);

template<bool bMFCDLL>
CStringT& operator=(const CSimpleStringT<BaseType, bMFCDLL>& str);
CStringT& operator=(PCXSTR pszSrc);
CStringT& operator=(PCYSTR pszSrc);
CStringT& operator=(const unsigned char* pszSrc);
CStringT& operator=(XCHAR ch);
CStringT& operator=(YCHAR ch);
CStringT& operator=(const VARIANT& var);

Parameterar

strSrc
A CStringT för att tilldela till den här strängen.

str
En referens till ett CThisSimpleString objekt.

bMFCDLL
Ett booleskt värde som anger om projektet är en MFC DLL eller inte.

BaseType
Strängbastypen.

var
Ett variantobjekt som ska tilldelas till den här strängen.

ch
Ett ANSI- eller Unicode-tecken som ska tilldelas till strängen.

pszSrc
En pekare till den ursprungliga strängen som tilldelas.

Anmärkningar

Tilldelningsoperatorn accepterar ett annat CStringT objekt, en teckenpekare eller ett enda tecken. Minnesfel kan inträffa när du använder den här operatorn eftersom ny lagring kan allokeras.

Mer information om CThisSimpleStringfinns i avsnittet Anmärkningar i CStringT::CStringT.

CStringT::operator +

Sammanfogar två strängar eller ett tecken och en sträng.

friend CStringT operator+(const CStringT& str1, const CStringT& str2);
friend CStringT operator+(const CStringT& str1, PCXSTR psz2);
friend CStringT operator+(PCXSTR psz1, const CStringT& str2);
friend CStringT operator+(char ch1, const CStringT& str2);
friend CStringT operator+(const CStringT& str1, char ch2);
friend CStringT operator+(const CStringT& str1, wchar_t ch2);
friend CStringT operator+(wchar_t ch1, const CStringT& str2);

Parameterar

ch1
Ett ANSI- eller Unicode-tecken som sammanfogas med en sträng.

ch2
Ett ANSI- eller Unicode-tecken som sammanfogas med en sträng.

str1
A CStringT för att sammanfoga med en sträng eller ett tecken.

str2
A CStringT för att sammanfoga med en sträng eller ett tecken.

psz1
En pekare till en null-avslutad sträng som sammanfogas med en sträng eller ett tecken.

psz2
En pekare till en sträng som sammanfogas med en sträng eller ett tecken.

Anmärkningar

Det finns sju överlagringsformer av CStringT::operator+ funktionen. Den första versionen sammanfogar två befintliga CStringT objekt. Nästa två sammanfogar ett CStringT objekt och en null-avslutad sträng. Nästa två sammanfogar ett CStringT objekt och ett ANSI-tecken. De två sista sammanfogar ett CStringT objekt och ett Unicode-tecken.

Exempel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("dog ")), s2(_T(" awake")), s3;  // Empty CAtlString objects

s1= _T("The ") + s1;
s3= s1 + _T('i');
s3= s3 + _T('s');
s3= s3 + s2;
ASSERT(s3 == _T("The dog is awake"));   

CStringT::operator +=

Sammanfogar tecken till slutet av strängen.

CStringT& operator+=(const CThisSimpleString& str);

template<bool bMFCDLL>
CStringT& operator+=(const const CSimpleStringT<BaseType, bMFCDLL>& str);

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

Parameterar

str
En referens till ett CThisSimpleString objekt.

bMFCDLL
Ett booleskt värde som anger om projektet är en MFC DLL eller inte.

BaseType
Strängbastypen.

var
Ett variantobjekt som ska sammanfogas med den här strängen.

ch
Ett ANSI- eller Unicode-tecken som sammanfogas med en sträng.

pszSrc
En pekare till den ursprungliga strängen som sammanfogas.

strSrc
A CStringT för att sammanfoga till den här strängen.

Anmärkningar

Operatorn accepterar ett annat CStringT objekt, en teckenpekare eller ett enda tecken. 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 CStringT objektet.

Mer information om CThisSimpleStringfinns i avsnittet Anmärkningar i CStringT::CStringT.

Exempel

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

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

CStringT::operator ==

Avgör om två strängar är logiskt lika med.

friend bool operator==(const CStringT& str1, const CStringT& str2) throw();
friend bool operator==(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator==(const CStringT& str1, PCYSTR psz2) throw();
friend bool operator==(const CStringT& str1, XCHAR ch2) throw();
friend bool operator==(PCXSTR psz1, const CStringT& str2) throw();
friend bool operator==(PCYSTR psz1, const CStringT& str2) throw();
friend bool operator==(XCHAR ch1, const CStringT& str2) throw();

Parameterar

ch1
Ett ANSI- eller Unicode-tecken för jämförelse.

ch2
Ett ANSI- eller Unicode-tecken för jämförelse.

str1
En CStringT för jämförelse.

str2
En CStringT för jämförelse.

psz1
En pekare till en null-avslutad sträng för jämförelse.

psz2
En pekare till en null-avslutad sträng för jämförelse.

Anmärkningar

Testar om en sträng eller ett tecken på vänster sida är lika med en sträng eller ett tecken på höger sida och returnerar TRUE eller FALSE därefter.

Exempel

// typedef CStringT< TCHAR, StrTraitATL< TCHAR > > CAtlString;
CAtlString s1(_T("dog")), s2(_T("f")), s3(_T("dog"));

ASSERT(s1 == _T("dog"));
ASSERT(s2 == _T('f'));
ASSERT(s1 == s3);   

CStringT::operator !=

Avgör om två strängar är logiskt lika med.

friend bool operator!=(const CStringT& str1, const CStringT& str2) throw();
friend bool operator!=(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator!=(const CStringT& str1, PCYSTR psz2) throw();
friend bool operator!=(const CStringT& str1, XCHAR ch2) throw();
friend bool operator!=(PCXSTR psz1, const CStringT& str2) throw();
friend bool operator!=(PCYSTR psz1, const CStringT& str2) throw();
friend bool operator!=(XCHAR ch1, const CStringT& str2) throw();

Parameterar

ch1
Ett ANSI- eller Unicode-tecken som sammanfogas med en sträng.

ch2
Ett ANSI- eller Unicode-tecken som sammanfogas med en sträng.

str1
En CStringT för jämförelse.

str2
En CStringT för jämförelse.

psz1
En pekare till en null-avslutad sträng för jämförelse.

psz2
En pekare till en null-avslutad sträng för jämförelse.

Anmärkningar

Testar om en sträng eller ett tecken på vänster sida inte är lika med en sträng eller ett tecken till höger.

Exempel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("f")), s3(_T("horse"));

ASSERT(s1 != _T("dog"));
ASSERT(s2 != _T('t'));
ASSERT(s1 != s2);   

CStringT::operator <

Avgör om strängen till vänster om operatorn är mindre än strängen på höger sida.

friend bool operator<(const CStringT& str1, const CStringT& str2) throw();
friend bool operator<(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator<(PCXSTR psz1, const CStringT& str2) throw();

Parameterar

str1
En CStringT för jämförelse.

str2
En CStringT för jämförelse.

psz1
En pekare till en null-avslutad sträng för jämförelse.

psz2
En pekare till en null-avslutad sträng för jämförelse.

Anmärkningar

En lexicographical jämförelse mellan strängar, tecken efter tecken tills:

• Den hittar två motsvarande tecken som är olika och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan strängarna.

• Den hittar inga skillnader, men den ena strängen har fler tecken än den andra, och den kortare strängen anses vara mindre än den längre strängen.

• Den hittar inga skillnader och upptäcker att strängarna har samma antal tecken, och därför är strängarna lika.

Exempel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("cats")), s3(_T("dogs"));

ASSERT(s1 < _T("dog"));
ASSERT(s1 < _T("cats"));
ASSERT(s2 < _T("cats and dogs"));
ASSERT(s2 < s3);   

CStringT::operator >

Avgör om strängen till vänster om operatorn är större än strängen till höger.

friend bool operator>(const CStringT& str1, const CStringT& str2) throw();
friend bool operator>(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator>(PCXSTR psz1, const CStringT& str2) throw();

Parameterar

str1
En CStringT för jämförelse.

str2
En CStringT för jämförelse.

psz1
En pekare till en null-avslutad sträng för jämförelse.

psz2
En pekare till en null-avslutad sträng för jämförelse.

Anmärkningar

En lexicographical jämförelse mellan strängar, tecken efter tecken tills:

• Den hittar två motsvarande tecken som är olika och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan strängarna.

• Den hittar inga skillnader, men den ena strängen har fler tecken än den andra, och den kortare strängen anses vara mindre än den längre strängen.

• Den hittar inga skillnader och upptäcker att strängarna har samma antal tecken, så strängarna är lika.

Exempel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("cats")), s3(_T("dogs"));
ASSERT(_T("dog") > s1);
ASSERT(_T("cats") > s1);
ASSERT(_T("cats and dogs") > s2);
ASSERT(s3 > s2);   

CStringT::operator <=

Avgör om strängen till vänster om operatorn är mindre än eller lika med strängen till höger.

friend bool operator<=(const CStringT& str1, const CStringT& str2) throw();
friend bool operator<=(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator<=(PCXSTR psz1, const CStringT& str2) throw();

Parameterar

str1
En CStringT för jämförelse.

str2
En CStringT för jämförelse.

psz1
En pekare till en null-avslutad sträng för jämförelse.

psz2
En pekare till en null-avslutad sträng för jämförelse.

Anmärkningar

En lexicographical jämförelse mellan strängar, tecken efter tecken tills:

• Den hittar två motsvarande tecken som är olika och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan strängarna.

• Den hittar inga skillnader, men den ena strängen har fler tecken än den andra, och den kortare strängen anses vara mindre än den längre strängen.

• Den hittar inga skillnader och upptäcker att strängarna har samma antal tecken, så strängarna är lika.

Exempel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("cats")), s3(_T("dogs"));

ASSERT(s1 <= _T("dog"));
ASSERT(s1 <= _T("cat"));
ASSERT(s3 <= _T("dogs and cats"));
ASSERT(s2 <= s3);   

CStringT::operator >=

Avgör om strängen till vänster om operatorn är större än eller lika med strängen till höger.

friend bool operator>=(const CStringT& str1, const CStringT& str2) throw();
friend bool operator>=(const CStringT& str1, PCXSTR psz2) throw();
friend bool operator>=(PCXSTR psz1, const CStringT& str2) throw();

Parameterar

str1
En CStringT för jämförelse.

str2
En CStringT för jämförelse.

psz1
En pekare till en sträng för jämförelse.

psz2
En pekare till en sträng för jämförelse.

Anmärkningar

En lexicographical jämförelse mellan strängar, tecken efter tecken tills:

• Den hittar två motsvarande tecken som är olika och resultatet av deras jämförelse tas som ett resultat av jämförelsen mellan strängarna.

• Den hittar inga skillnader, men den ena strängen har fler tecken än den andra, och den kortare strängen anses vara mindre än den längre strängen.

• Den hittar inga skillnader och upptäcker att strängarna har samma antal tecken, så strängarna är lika.

Exempel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString s1(_T("cat")), s2(_T("cats")), s3(_T("dogs"));

ASSERT(_T("dog") >= s1);
ASSERT(_T("cats and dogs") >= s2);
ASSERT(s3 >= s2);   

CStringT::Remove

Tar bort alla instanser av det angivna tecknet från strängen.

int Remove(XCHAR chRemove);

Parameterar

chRemove
Tecknet som ska tas bort från en sträng.

Returvärde

Antalet tecken som tagits bort från strängen. Noll om strängen inte ändras.

Anmärkningar

Jämförelser för tecknet är skiftlägeskänsliga.

Exempel

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

CAtlString str(_T("This is a test."));
int n = str.Remove(_T('t'));
ASSERT(n == 2);
ASSERT(str == _T("This is a es."));   

CStringT::Replace

Det finns två versioner av Replace. Den första versionen ersätter en eller flera kopior av en delsträng med hjälp av en annan delsträng. Båda delsträngarna är null-avslutade. Den andra versionen ersätter en eller flera kopior av ett tecken med hjälp av ett annat tecken. Båda versionerna fungerar på teckendata som lagras i CStringT.

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

Parameterar

pszOld
En pekare till en null-avslutad sträng som ska ersättas av pszNew.

pszNew
En pekare till en null-avslutad sträng som ersätter pszOld.

chOld
Tecknet som ska ersättas av chNew.

chNew
Tecknet ersätter chOld.

Returvärde

Returnerar antalet ersatta instanser av tecknet eller delsträngen, eller noll om strängen inte ändras.

Anmärkningar

Replace kan ändra stränglängden eftersom pszNew och pszOld inte behöver vara samma längd, och flera kopior av den gamla delsträngen kan ändras till den nya. Funktionen gör en skiftlägeskänslig matchning.

Exempel på CStringT instanser är CString, CStringAoch CStringW.

För CStringAfungerar Replace med ANSI- eller MBCS-tecken (multibyte). För CStringWfungerar Replace med breda tecken.

För CStringär teckendatatypen vald vid kompileringstid, baserat på om konstanterna i följande tabell har definierats.

Exempel

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

CAtlString strBang(_T("Everybody likes epee fencing"));
int n = strBang.Replace(_T("epee"), _T("foil"));
ASSERT(n == 1);   

CStringT::ReverseFind

Söker i det här CStringT objektet efter den sista matchningen av ett tecken.

int ReverseFind(XCHAR ch) const throw();

Parameterar

ch
Tecknet att söka efter.

Returvärde

Det nollbaserade indexet för det sista tecknet i det här CStringT objektet som matchar det begärda tecknet, eller -1 om tecknet inte hittas.

Anmärkningar

Funktionen liknar körningsfunktionen strrchr.

Exempel

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

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

CStringT::Right

Extraherar de sista (dvs. längst till höger) nCount tecknen från det här CStringT objektet och returnerar en kopia av den extraherade delsträngen.

CStringT Right(int nCount) const;

Parameterar

nCount
Antalet tecken som ska extraheras från det här CStringT objektet.

Returvärde

Ett CStringT objekt som innehåller en kopia av det angivna teckenintervallet. Det returnerade CStringT objektet kan vara tomt.

Anmärkningar

Om nCount överskrider stränglängden extraheras hela strängen. Right liknar funktionen Basic Right (förutom att index i Basic är nollbaserade).

För flerbytesteckenuppsättningar (MBCS), nCount refererar till varje 8-bitars tecken, dvs. en lead- och trail-byte i ett flerbytestecken räknas som två tecken.

Exempel

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

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

CStringT::SetSysString

Omallokerar det BSTR som pekas på och pbstr kopierar innehållet CStringT i objektet till det, inklusive NULL tecknet.

BSTR SetSysString(BSTR* pbstr) const;

Parameterar

pbstr
En pekare till en teckensträng.

Returvärde

Den nya strängen.

Anmärkningar

Beroende på innehållet i CStringT objektet kan värdet för det BSTR som refereras av pbstr ändras. Funktionen genererar ett CMemoryException om det inte finns tillräckligt med minne.

Den här funktionen används normalt för att ändra värdet för strängar som skickas som referens för Automation.

Exempel

BSTR bstr = ::SysAllocString(L"Golf is fun!");

// create a CAtlString and change the OLE
// string to the contents of the BSTR
// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString str(_T("Soccer is best!"));
BSTR bstr2 = str.SetSysString(&bstr);

// Now, both bstr and bstr2 reference a single instance of
// the "Soccer" string. The "Golf" string has been freed.
ASSERT(bstr2 == bstr);   

CStringT::SpanExcluding

Extraherar tecken från strängen, från och med det första tecknet, som inte finns i den uppsättning tecken som identifieras av pszCharSet.

CStringT SpanExcluding(PCXSTR pszCharSet) const;

Parameterar

pszCharSet
En sträng som tolkas som en uppsättning tecken.

Returvärde

En delsträng som innehåller tecken i strängen som inte finns i pszCharSet, som börjar med det första tecknet i strängen och slutar med det första tecknet som finns i strängen som också finns i pszCharSet (dvs. börjar med det första tecknet i strängen och upp till men exkluderar det första tecknet i strängen som hittas pszCharSet). Den returnerar hela strängen om inget tecken i pszCharSet hittas i strängen.

Anmärkningar

SpanExcluding extraherar och returnerar alla tecken som föregår den första förekomsten av ett tecken från pszCharSet (med andra ord returneras inte tecknet från pszCharSet och alla tecken som följer efter det i strängen). Om inget tecken från pszCharSet hittas i strängen returnerar du SpanExcluding hela strängen.

Exempel

// The string can be delimited by a semicolon(;),
//  a comma(,), a period(.), a dash(-),
// or an apostrophe(').
// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;

CAtlString src(_T("abcdef"));

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

CStringT::SpanIncluding

Extraherar tecken från strängen, från och med det första tecknet, som finns i den uppsättning tecken som identifieras av pszCharSet.

CStringT SpanIncluding(PCXSTR pszCharSet) const;

Parameterar

pszCharSet
En sträng som tolkas som en uppsättning tecken.

Returvärde

En understräng som innehåller tecken i strängen som är i pszCharSet, som börjar med det första tecknet i strängen och slutar när ett tecken hittas i strängen som inte finns i pszCharSet. SpanIncluding returnerar en tom delsträng om det första tecknet i strängen inte finns i den angivna uppsättningen.

Anmärkningar

Om strängens första tecken inte finns i teckenuppsättningen returnerar du SpanIncluding en tom sträng. Annars returneras en sekvens med efterföljande tecken som finns i uppsättningen.

Exempel

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

CAtlString str(_T("cabbage"));
CAtlString res = str.SpanIncluding(_T("abc"));
ASSERT(res == _T("cabba"));
res = str.SpanIncluding(_T("xyz"));
ASSERT(res.IsEmpty());   

CStringT::Tokenize

Hittar nästa token i en målsträng

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

Parameterar

pszTokens
En sträng som innehåller tokenavgränsare. Ordningen på dessa avgränsare är inte viktig.

iStart
Det nollbaserade indexet för att påbörja sökningen.

Returvärde

Ett CStringT objekt som innehåller det aktuella tokenvärdet.

Anmärkningar

Funktionen Tokenize hittar nästa token i målsträngen. Uppsättningen med tecken i pszTokens anger möjliga avgränsare av token som ska hittas. Vid varje anrop till Tokenize funktionen startar vid iStarthoppar du över inledande avgränsare och returnerar ett CStringT objekt som innehåller den aktuella token, som är strängen med tecken upp till nästa avgränsartecken. Värdet iStart för uppdateras för att vara positionen efter slutavgränsarens tecken, eller -1 om slutet av strängen har nåtts. Fler token kan brytas ut från resten av målsträngen genom en serie anrop till Tokenize, med hjälp iStart av för att hålla reda på var i strängen nästa token ska läsas. När det inte finns fler token returnerar funktionen en tom sträng och iStart anges till -1.

Till skillnad från crt-tokenize-funktioner som strtok_s, _strtok_s_l, wcstok_s, _wcstok_s_l, _mbstok_s, _mbstok_s_lTokenize ändrar inte målsträngen.

Exempel

// typedef CStringT<TCHAR, StrTraitATL<TCHAR, ChTraitsCRT<TCHAR>>> CAtlString;
CAtlString str(_T("%First Second#Third"));
CAtlString resToken;
int curPos = 0;

resToken= str.Tokenize(_T("% #"),curPos);
while (resToken != _T(""))
{
   _tprintf_s(_T("Resulting token: %s\n"), resToken);
   resToken = str.Tokenize(_T("% #"), curPos);
}

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

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

CStringT::Trim

Trimmar inledande och avslutande tecken från strängen.

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

Parameterar

chTarget
Måltecknet som ska trimmas.

pszTargets
En pekare till en sträng som innehåller måltecken som ska trimmas. Alla inledande och avslutande förekomster av tecken i pszTargets kommer att trimmas från CStringT objektet.

Returvärde

Returnerar den trimmade strängen.

Anmärkningar

Tar bort alla inledande och avslutande förekomster av något av följande:

• Tecknet som anges av chTarget.

• Alla tecken som finns i strängen som anges av pszTargets.

• Blanksteg.

Exempel

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

CAtlString str;
str = _T("******Soccer is best!?!?!?!?!");

_tprintf_s(_T("Before: \"%s\"\n"), (LPCTSTR)str);
_tprintf_s(_T("After : \"%s\"\n"), (LPCTSTR)str.Trim(_T("?!*")));

// Output:
// --------------------------
// Before: ******Soccer is best!?!?!?!?!
// After: Soccer is best

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

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

CStringT::TrimLeft

Trimmar inledande tecken från strängen.

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

Parameterar

chTarget
Måltecknet som ska trimmas.

pszTargets
En pekare till en sträng som innehåller måltecken som ska trimmas. Alla inledande förekomster av tecken i pszTargets kommer att trimmas från CStringT objektet.

Returvärde

Den resulterande trimmade strängen.

Anmärkningar

Tar bort alla inledande och avslutande förekomster av något av följande:

• Tecknet som anges av chTarget.

• Alla tecken som finns i strängen som anges av pszTargets.

• Blanksteg.

Exempel

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

CAtlString str;
str = _T("\t\t   ****Soccer is best!");

_tprintf_s(_T("Before: \"%s\"\n"), (LPCTSTR)str);
_tprintf_s(_T("After: \"%s\"\n"), (LPCTSTR)str.TrimLeft(_T("\t *")));

// Output:
// --------------------------
// Before:     ****Soccer is best!
// After: Soccer is best!

CStringT::TrimRight

Trimmar avslutande tecken från strängen.

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

Parameterar

chTarget
Måltecknet som ska trimmas.

pszTargets
En pekare till en sträng som innehåller måltecken som ska trimmas. Alla avslutande förekomster av tecken i pszTargets kommer att trimmas från CStringT objektet.

Returvärde

Returnerar det CStringT objekt som innehåller den trimmade strängen.

Anmärkningar

Tar bort efterföljande förekomster av något av följande:

• Tecknet som anges av chTarget.

• Alla tecken som finns i strängen som anges av pszTargets.

• Blanksteg.

Versionen CStringT& TrimRight(XCHAR chTarget) accepterar en teckenparameter och tar bort alla kopior av det tecknet från slutet av CStringT strängdata. Den börjar från slutet av strängen och fungerar mot framsidan. Den stoppas när den hittar ett annat tecken eller när CStringT det tar slut på teckendata.

Versionen CStringT& TrimRight(PCXSTR pszTargets) accepterar en null-avslutad sträng som innehåller alla olika tecken att söka efter. Den tar bort alla kopior av dessa tecken i CStringT objektet. Den börjar i slutet av strängen och fungerar mot framsidan. Den stoppas när den hittar ett tecken som inte finns i målsträngen eller när CStringT teckendata tar slut. Den försöker inte matcha hela målsträngen med en delsträng i slutet av CStringT.

Versionen CStringT& TrimRight() kräver inga parametrar. Den trimmar eventuella avslutande blankstegstecken från slutet av strängen CStringT . Blankstegstecken kan vara radbrytningar, blanksteg eller flikar.

Exempel

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

CAtlString str;
str = _T("Soccer is best!?!?!?!?!");

_tprintf_s(_T("Before: \"%s\"\n"), (LPCTSTR)str);
_tprintf_s(_T("After : \"%s\"\n"), (LPCTSTR)str.TrimRight(_T("?!")));

// Output:
// --------------------------
// Before: Soccer is best!?!?!?!?!
// After: Soccer is best

Se även

hierarkidiagram
DELADE ATL/MFC-klasser
CSimpleStringT klass