Classe `CStringT`

Articolo
10/12/2023

Questa classe rappresenta un CStringT oggetto .

Sintassi

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

Parametri

BaseType
Tipo di carattere della classe stringa. Può essere uno dei seguenti:

char (per stringhe di caratteri ANSI).
wchar_t (per stringhe di caratteri Unicode).
TCHAR (per stringhe di caratteri ANSI e Unicode).

StringTraits
Determina se la classe stringa richiede il supporto della libreria C Run-Time (CRT) e la posizione in cui si trovano le risorse stringa. Può essere uno dei seguenti:

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

La classe richiede il supporto CRT e cerca le stringhe di risorse nel modulo specificato da m_hInstResource (membro della classe module dell'applicazione).
StrTraitATL<wchar_t | char | TCHAR, ChTraitsOS<wchar_t | char |TCHAR>>

La classe non richiede il supporto CRT e cerca le stringhe di risorse nel modulo specificato da m_hInstResource (membro della classe module dell'applicazione).
StrTraitMFC<wchar_t | char | TCHAR, ChTraitsCRT<wchar_t | char | TCHAR>>

La classe richiede il supporto CRT e cerca le stringhe di risorse usando l'algoritmo di ricerca MFC standard.
StrTraitMFC<wchar_t | char | TCHAR, ChTraitsOS<wchar_t | char | TCHAR>>

La classe non richiede il supporto CRT e cerca stringhe di risorse usando l'algoritmo di ricerca MFC standard.

Membri

Costruttori pubblici

Nome	Descrizione
`CStringT::CStringT`	Costruisce un `CStringT` oggetto in vari modi.
`CStringT::~CStringT`	Elimina un oggetto `CStringT` .

Metodi pubblici

Nome	Descrizione
`CStringT::AllocSysString`	Alloca un oggetto `BSTR` dai `CStringT` dati.
`CStringT::AnsiToOem`	Esegue una conversione sul posto dal set di caratteri ANSI al set di caratteri OEM.
`CStringT::AppendFormat`	Aggiunge dati formattati a un oggetto esistente `CStringT` .
`CStringT::Collate`	Confronta due stringhe (con distinzione tra maiuscole e minuscole, usa informazioni specifiche delle impostazioni locali).
`CStringT::CollateNoCase`	Confronta due stringhe (senza distinzione tra maiuscole e minuscole, usa informazioni specifiche delle impostazioni locali).
`CStringT::Compare`	Confronta due stringhe (con distinzione tra maiuscole e minuscole).
`CStringT::CompareNoCase`	Confronta due stringhe (senza distinzione tra maiuscole e minuscole).
`CStringT::Delete`	Elimina un carattere o un carattere da una stringa.
`CStringT::Find`	Trova un carattere o una sottostringa all'interno di una stringa più grande.
`CStringT::FindOneOf`	Trova il primo carattere corrispondente da un set.
`CStringT::Format`	Formatta la stringa così come `sprintf` .
`CStringT::FormatMessage`	Formatta una stringa di messaggio.
`CStringT::FormatMessageV`	Formatta una stringa di messaggio usando un elenco di argomenti variabile.
`CStringT::FormatV`	Formatta la stringa usando un elenco variabile di argomenti.
`CStringT::GetEnvironmentVariable`	Imposta la stringa sul valore della variabile di ambiente specificata.
`CStringT::Insert`	Inserisce un singolo carattere o una sottostringa in corrispondenza dell'indice specificato all'interno della stringa.
`CStringT::Left`	Estrae la parte sinistra di una stringa.
`CStringT::LoadString`	Carica un oggetto esistente `CStringT` da una risorsa di Windows.
`CStringT::MakeLower`	Converte tutti i caratteri in questa stringa in caratteri minuscoli.
`CStringT::MakeReverse`	Inverte la stringa.
`CStringT::MakeUpper`	Converte tutti i caratteri in questa stringa in caratteri maiuscoli.
`CStringT::Mid`	Estrae la parte centrale di una stringa.
`CStringT::OemToAnsi`	Esegue una conversione sul posto dal set di caratteri OEM al set di caratteri ANSI.
`CStringT::Remove`	Rimuove i caratteri indicati da una stringa.
`CStringT::Replace`	Sostituisce i caratteri indicati con altri caratteri.
`CStringT::ReverseFind`	Trova un carattere all'interno di una stringa più grande; inizia dalla fine.
`CStringT::Right`	Estrae la parte destra di una stringa.
`CStringT::SetSysString`	Imposta un oggetto esistente `BSTR` con i dati di un `CStringT` oggetto .
`CStringT::SpanExcluding`	Estrae caratteri dalla stringa, a partire dal primo carattere, che non si trovano nel set di caratteri identificati da `pszCharSet`.
`CStringT::SpanIncluding`	Estrae una sottostringa che contiene solo i caratteri di un set.
`CStringT::Tokenize`	Estrae i token specificati in una stringa di destinazione.
`CStringT::Trim`	Taglia tutti gli spazi vuoti iniziali e finali dalla stringa.
`CStringT::TrimLeft`	Taglia gli spazi vuoti iniziali dalla stringa.
`CStringT::TrimRight`	Taglia gli spazi vuoti finali dalla stringa.

Operatori

Nome	Descrizione
`CStringT::operator =`	Assegna un nuovo valore a un `CStringT` oggetto .
`CStringT::operator +`	Concatena due stringhe o un carattere e una stringa.
`CStringT::operator +=`	Concatena una nuova stringa alla fine di una stringa esistente.
`CStringT::operator ==`	Determina se due stringhe sono logicamente uguali.
`CStringT::operator !=`	Determina se due stringhe non sono logicamente uguali.
`CStringT::operator <`	Determina se la stringa sul lato sinistro dell'operatore è minore di quella della stringa sul lato destro.
`CStringT::operator >`	Determina se la stringa sul lato sinistro dell'operatore è maggiore della stringa sul lato destro.
`CStringT::operator <=`	Determina se la stringa a sinistra dell'operatore è minore o uguale alla stringa sul lato destro.
`CStringT::operator >=`	Determina se la stringa a sinistra dell'operatore è maggiore o uguale alla stringa sul lato destro.

Osservazioni:

CStringT eredita da CSimpleStringT Class. Le funzionalità avanzate, ad esempio la manipolazione dei caratteri, l'ordinamento e la ricerca, vengono implementate da CStringT.

Nota

CStringT gli oggetti sono in grado di generare eccezioni. Ciò si verifica quando un CStringT oggetto esaurisce la memoria per qualsiasi motivo.

Un CStringT oggetto è costituito da una sequenza di caratteri a lunghezza variabile. CStringT fornisce funzioni e operatori che usano una sintassi simile a quella di Basic. La concatenazione e gli operatori di confronto, insieme alla gestione semplificata della memoria, semplificano CStringT l'uso degli oggetti rispetto alle matrici di caratteri normali.

Nota

Sebbene sia possibile creare CStringT istanze che contengono caratteri Null incorporati, è consigliabile usarle. La chiamata di metodi e operatori su CStringT oggetti contenenti caratteri Null incorporati può produrre risultati imprevisti.

Usando diverse combinazioni dei BaseType parametri e StringTraits , CStringT gli oggetti possono venire nei tipi seguenti, che sono stati predefiniti dalle librerie ATL.

Se si usa in un'applicazione ATL:

CString, CStringAe CStringW vengono esportati dalla DLL MFC (MFC90.DLL), mai dalle DLL utente. Questa operazione viene eseguita per evitare CStringT di essere definita più volte.

Nota

Se il codice contiene la soluzione alternativa per gli errori del linker descritti in Esportazione di classi di stringhe tramite CStringT, è necessario rimuovere tale codice. Non è più necessario.

I tipi di stringa seguenti sono disponibili nelle applicazioni basate su MFC:

Tipo CStringT	Dichiarazione
`CStringA`	Stringa del tipo di carattere ANSI con supporto CRT.
`CStringW`	Stringa di tipo carattere Unicode con supporto CRT.
`CString`	Entrambi i tipi di caratteri ANSI e Unicode con supporto CRT.

I tipi di stringa seguenti sono disponibili nei progetti in cui ATL_CSTRING_NO_CRT è definito:

Tipo CStringT	Dichiarazione
`CAtlStringA`	Stringa di tipo carattere ANSI senza supporto CRT.
`CAtlStringW`	Stringa di tipo carattere Unicode senza supporto CRT.
`CAtlString`	Entrambi i tipi di caratteri ANSI e Unicode senza supporto CRT.

I tipi di stringa seguenti sono disponibili nei progetti in cui ATL_CSTRING_NO_CRT non è definito:

Tipo CStringT	Dichiarazione
`CAtlStringA`	Stringa del tipo di carattere ANSI con supporto CRT.
`CAtlStringW`	Stringa di tipo carattere Unicode con supporto CRT.
`CAtlString`	Entrambi i tipi di caratteri ANSI e Unicode con supporto CRT.

CString gli oggetti presentano anche le caratteristiche seguenti:

CStringT gli oggetti possono aumentare a causa di operazioni di concatenazione.
CStringT gli oggetti seguono la "semantica del valore". Si consideri un CStringT oggetto come una stringa effettiva, non come puntatore a una stringa.
È possibile sostituire CStringT liberamente gli oggetti per PCXSTR gli argomenti della funzione.
Gestione della memoria personalizzata per i buffer di stringhe. Per altre informazioni, vedere Gestione della memoria e CStringT.

Tipi predefiniti CStringT

Poiché CStringT usa un argomento modello per definire il tipo di carattere ( wchar_t o char) supportato, i tipi di parametro del metodo possono essere complicati a volte. Per semplificare questo problema, viene definito e usato un set di tipi predefiniti in tutta la CStringT classe. Nella tabella seguente sono elencati i vari tipi:

Nome	Descrizione
`XCHAR`	Un singolo carattere ( `wchar_t` o `char`) con lo stesso tipo di carattere dell'oggetto `CStringT` .
`YCHAR`	Un singolo carattere ( `wchar_t` o `char`) con il tipo di carattere opposto come `CStringT` oggetto .
`PXSTR`	Puntatore a una stringa di caratteri ( `wchar_t` o `char`) con lo stesso tipo di carattere dell'oggetto `CStringT` .
`PYSTR`	Puntatore a una stringa di caratteri ( `wchar_t` o `char`) con il tipo di carattere opposto come `CStringT` oggetto .
`PCXSTR`	Puntatore a una `const` stringa di caratteri ( `wchar_t` o `char`) con lo stesso tipo di carattere dell'oggetto `CStringT` .
`PCYSTR`	Puntatore a una `const` stringa di caratteri ( `wchar_t` o `char`) con il tipo di carattere opposto come `CStringT` oggetto .

Nota

Il codice che in precedenza usava metodi non documentati di CString (ad esempio AssignCopy) deve essere sostituito con il codice che usa i metodi documentati seguenti di CStringT (ad esempio GetBuffer o ReleaseBuffer). Questi metodi vengono ereditati da CSimpleStringT.

Gerarchia di ereditarietà

CSimpleStringT

CStringT

Requisiti

Intestazione	Usare per
`cstringt.h`	Oggetti stringa solo MFC
`atlstr.h`	Oggetti stringa non MFC

`CStringT::AllocSysString`

Alloca una stringa compatibile con l'automazione del tipo BSTR e copia il contenuto dell'oggetto CStringT in esso, incluso il carattere Null di terminazione.

BSTR AllocSysString() const;

Valore restituito

Stringa appena allocata.

Osservazioni:

Nei programmi MFC viene generata una CMemoryException classe se esiste memoria insufficiente. Nei programmi ATL viene generata un'eccezione CAtlException . Questa funzione viene in genere usata per restituire stringhe per l'automazione.

In genere, se questa stringa viene passata a una funzione COM come [in] parametro, è necessario che il chiamante liberi la stringa. A tale scopo, usare SysFreeString, come descritto in Windows SDK. Per altre informazioni, vedere Allocazione e rilascio della memoria per un oggetto BSTR.

Per altre informazioni sulle funzioni di allocazione OLE in Windows, vedere SysAllocString in Windows SDK.

Esempio

L'esempio seguente illustra l'uso di 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`

Converte tutti i caratteri in questo CStringT oggetto dal set di caratteri ANSI al set di caratteri OEM.

void AnsiToOem();

Osservazioni:

La funzione non è disponibile se _UNICODE è definita.

Esempio

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

Aggiunge dati formattati a un oggetto esistente CStringT .

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

Parametri

pszFormat
Stringa di controllo di formato.

nFormatID
Identificatore di risorsa stringa che contiene la stringa di controllo del formato.

argument
Argomenti facoltativi.

Osservazioni:

Questa funzione formatta e aggiunge una serie di caratteri e valori in CStringT. Ogni argomento facoltativo (se presente) viene convertito e accodato in base alla specifica di formato corrispondente in pszFormat o dalla risorsa stringa identificata da nFormatID.

Esempio

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

Confronta due stringhe usando la funzione _tcscollgeneric-text .

int Collate(PCXSTR psz) const throw();

Parametri

psz
Altra stringa utilizzata per il confronto.

Valore restituito

Zero se le stringhe sono identiche, < 0 se questo CStringT oggetto è minore di pszo > 0 se l'oggetto CStringT è maggiore di psz.

Osservazioni:

La funzione _tcscollgeneric-text , definita in TCHAR.H, esegue il mapping a strcoll, wcscollo _mbscoll, a seconda del set di caratteri definito in fase di compilazione. Ogni funzione esegue un confronto con distinzione tra maiuscole e minuscole delle stringhe in base alla tabella codici attualmente in uso. Per altre informazioni, vedere strcoll, wcscoll_mbscoll, _strcoll_l, , _wcscoll_l_mbscoll_l.

`CStringT::CollateNoCase`

Confronta due stringhe usando la funzione _tcscollgeneric-text .

int CollateNoCase(PCXSTR psz) const throw();

Parametri

psz
Altra stringa utilizzata per il confronto.

Valore restituito

Zero se le stringhe sono identiche (ignorando la distinzione tra maiuscole e minuscole), < 0 se l'oggetto CStringT è minore di psz (ignorando la distinzione tra maiuscole e minuscole) o > 0 se l'oggetto CStringT è maggiore di psz (ignorando la distinzione tra maiuscole e minuscole).

Osservazioni:

La funzione _tcscollgeneric-text , definita in TCHAR.H, esegue il mapping a stricoll, wcsicollo _mbsicoll, a seconda del set di caratteri definito in fase di compilazione. Ogni funzione esegue un confronto senza distinzione tra maiuscole e minuscole delle stringhe, in base alla tabella codici attualmente in uso. Per altre informazioni, vedere strcoll, wcscoll, _mbscoll_strcoll_l, , _wcscoll_l, . _mbscoll_l

Esempio

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

Confronta due stringhe (con distinzione tra maiuscole e minuscole).

int Compare(PCXSTR psz) const;

Parametri

psz
Altra stringa utilizzata per il confronto.

Valore restituito

Zero se le stringhe sono identiche, < 0 se questo CStringT oggetto è minore di pszo > 0 se l'oggetto CStringT è maggiore di psz.

Osservazioni:

La funzione _tcscmpgeneric-text , definita in TCHAR.H, esegue il mapping a strcmp, wcscmpo _mbscmp, a seconda del set di caratteri definito in fase di compilazione. Ogni funzione esegue un confronto con distinzione tra maiuscole e minuscole delle stringhe e non è interessato dalle impostazioni locali. Per altre informazioni, vedere , , _mbscmpwcscmp.strcmp

Se la stringa contiene valori Null incorporati, ai fini del confronto la stringa viene considerata troncata al primo carattere Null incorporato.

Esempio

L'esempio seguente illustra l'uso di 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`

Confronta due stringhe (senza distinzione tra maiuscole e minuscole).

int CompareNoCase(PCXSTR psz) const throw();

Parametri

psz
Altra stringa utilizzata per il confronto.

Valore restituito

Zero se le stringhe sono identiche (ignorando la distinzione tra maiuscole e minuscole), <0 se l'oggetto CStringT è minore di psz (ignorando la distinzione tra maiuscole e minuscole) o >0 se l'oggetto CStringT è maggiore di psz (ignorando la distinzione tra maiuscole e minuscole).

Osservazioni:

La funzione _tcsicmpgeneric-text , definita in TCHAR.H, esegue il mapping a _stricmp, _wcsicmp o _mbsicmp, a seconda del set di caratteri definito in fase di compilazione. Ogni funzione esegue un confronto senza distinzione tra maiuscole e minuscole delle stringhe. Il confronto dipende dall'aspetto LC_CTYPE delle impostazioni locali, ma non LC_COLLATEda . Per altre informazioni, vedere _stricmp, _wcsicmp, _mbsicmp_stricmp_l, , _wcsicmp_l, . _mbsicmp_l

Esempio

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

Costruisce un oggetto CStringT.

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

Parametri

pch
Puntatore a una matrice di caratteri di lunghezza nLength, non con terminazione Null.

nLength
Conteggio del numero di caratteri in pch.

ch
Un singolo carattere.

pszSrc
Stringa con terminazione Null da copiare in questo CStringT oggetto.

pStringMgr
Puntatore al gestore della memoria per l'oggetto CStringT . Per altre informazioni sulla IAtlStringMgr gestione della memoria per CStringT, vedere Gestione della memoria con CStringT.

strSrc
Oggetto esistente CStringT da copiare in questo CStringT oggetto. Per altre informazioni su CThisString e CThisSimpleString, vedere la sezione Osservazioni.

varSrc
Oggetto variant da copiare in questo CStringT oggetto.

BaseType
Tipo di carattere della classe stringa. Può essere uno dei seguenti:

char (per stringhe di caratteri ANSI).

wchar_t (per stringhe di caratteri Unicode).

TCHAR (per stringhe di caratteri ANSI e Unicode).

bMFCDLL
Valore booleano che specifica se il progetto è una DLL MFC (TRUE) o meno (FALSE).

SystemString
Deve essere System::Stringe il progetto deve essere compilato con /clr.

pString
Handle per un CStringT oggetto .

Osservazioni:

Poiché i costruttori copiano i dati di input in una nuova risorsa di archiviazione allocata, possono verificarsi eccezioni di memoria. Alcuni di questi costruttori fungono da funzioni di conversione. In questo modo è possibile sostituire, ad esempio, un oggetto LPTSTR in cui è previsto un CStringT oggetto.

CStringT( LPCSTR lpsz ): costruisce un unicode CStringT da una stringa ANSI. È anche possibile usare questo costruttore per caricare una risorsa stringa, come illustrato nell'esempio seguente.
CStringT(LPCWSTR lpsz ): costruisce un oggetto CStringT da una stringa Unicode.
CStringT( const unsigned char* psz ): consente di costruire un oggetto CStringT da un puntatore a unsigned char.

Nota

Definire la macro per disattivare la _CSTRING_DISABLE_NARROW_WIDE_CONVERSION conversione implicita di stringhe tra stringhe ANSI e Unicode. La macro esclude dai costruttori di compilazione che supportano la conversione.

Il strSrc parametro può essere un CStringT oggetto o CThisSimpleString . Per CStringT, usare una delle relative istanze predefinite (CString, CStringAo CStringW); per CThisSimpleString, usare un this puntatore. CThisSimpleString dichiara un'istanza CSimpleStringT della classe , che è una classe stringa più piccola con funzionalità meno predefinite rispetto alla CStringT classe .

L'operatore di CSimpleStringT<>&() overload costruisce un CStringT oggetto da una CSimpleStringT dichiarazione.

Nota

Esempio

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

Elimina definitivamente l'oggetto CStringT .

~CStringT() throw();

Osservazioni:

Elimina definitivamente l'oggetto CStringT .

`CStringT::Delete`

Elimina un carattere o un carattere da una stringa che inizia con il carattere in corrispondenza dell'indice specificato.

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

Parametri

iIndex
Indice in base zero del primo carattere nell'oggetto CStringT da eliminare.

nCount
Numero di caratteri da rimuovere.

Valore restituito

Lunghezza della stringa modificata.

Osservazioni:

Se nCount è più lunga della stringa, il resto della stringa verrà rimosso.

Esempio

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

Cerca in questa stringa la prima corrispondenza di un carattere o di una sottostringa.

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

Parametri

pszSub
Sottostringa da cercare.

iStart
Indice del carattere nella stringa con cui iniziare la ricerca oppure 0 da iniziare dall'inizio.

ch
Un singolo carattere da cercare.

Valore restituito

Indice in base zero del primo carattere in questo CStringT oggetto che corrisponde alla sottostringa o ai caratteri richiesti; -1 se la sottostringa o il carattere non viene trovato.

Osservazioni:

La funzione è in overload per accettare sia singoli caratteri (simili alla funzione strchrdi runtime) che stringhe (simili a strstr).

Esempio

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

Cerca in questa stringa il primo carattere corrispondente a qualsiasi carattere contenuto in pszCharSet.

int FindOneOf(PCXSTR pszCharSet) const throw();

Parametri

pszCharSet
Stringa contenente caratteri per la corrispondenza.

Valore restituito

Indice in base zero del primo carattere in questa stringa anch'esso in pszCharSet; -1 se non esiste alcuna corrispondenza.

Osservazioni:

Trova la prima occorrenza di uno dei caratteri in pszCharSet.

Esempio

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

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

`CStringT::Format`

Scrive i dati formattati in un oggetto CStringT nello stesso modo in cui sprintf_s i dati vengono formattati in una matrice di caratteri in stile C.

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

Parametri

nFormatID
Identificatore di risorsa stringa che contiene la stringa di controllo del formato.

pszFormat
Stringa di controllo di formato.

argument
Argomenti facoltativi.

Osservazioni:

Questa funzione formatta e archivia una serie di caratteri e valori in CStringT. Ogni argomento facoltativo (se presente) viene convertito e restituito in base alla specifica di formato corrispondente in pszFormat o dalla risorsa stringa identificata da nFormatID.

La chiamata avrà esito negativo se l'oggetto stringa stesso viene offerto come parametro a Format. Ad esempio, il codice seguente causerà risultati imprevedibili:

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

Per altre informazioni, vedere Sintassi delle specifiche di formato: printf e wprintf Funzioni.

Esempio

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

Formatta una stringa di messaggio.

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

Parametri

nFormatID
Identificatore di risorsa stringa che contiene il testo del messaggio non formattato.

pszFormat
Punta alla stringa del controllo formato. Verrà analizzata per gli inserimenti e formattati di conseguenza. La stringa di formato è simile alle stringhe di formato della funzione printfdi runtime, ad eccezione del fatto che consente l'inserimento dei parametri in un ordine arbitrario.

argument
Argomenti facoltativi.

Osservazioni:

La funzione richiede una definizione di messaggio come input. La definizione del messaggio è determinata da pszFormat o dalla risorsa stringa identificata da nFormatID. La funzione copia il testo del messaggio formattato nell'oggetto CStringT , elaborando eventuali sequenze di inserimento incorporate, se richiesto.

Nota

FormatMessage tenta di allocare memoria di sistema per la stringa appena formattata. Se questo tentativo non riesce, viene generata automaticamente un'eccezione di memoria.

Ogni inserimento deve avere un parametro corrispondente che segue il pszFormat parametro o nFormatID . All'interno del testo del messaggio sono supportate diverse sequenze di escape per la formattazione dinamica del messaggio. Per altre informazioni, vedere la funzione Windows FormatMessage in Windows SDK.

Esempio

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

Formatta una stringa di messaggio usando un elenco di argomenti variabile.

void FormatMessageV(PCXSTR pszFormat, va_list* pArgList);

Parametri

pszFormat
Punta alla stringa del controllo formato. Verrà analizzata per gli inserimenti e formattati di conseguenza. La stringa di formato è simile alle stringhe di formato della funzione printfdi runtime, ad eccezione del fatto che consente l'inserimento dei parametri in un ordine arbitrario.

pArgList
Puntatore a un elenco di argomenti.

Osservazioni:

La funzione richiede una definizione di messaggio come input, determinata da pszFormat. La funzione copia il testo formattato del messaggio e un elenco variabile di argomenti nell'oggetto CStringT , elaborando eventuali sequenze di inserimento incorporate, se richiesto.

Nota

FormatMessageV chiama CStringT::FormatMessage, che tenta di allocare memoria di sistema per la stringa appena formattata. Se questo tentativo non riesce, viene generata automaticamente un'eccezione di memoria.

Per altre informazioni, vedere la funzione Windows FormatMessage in Windows SDK.

`CStringT::FormatV`

Formatta una stringa di messaggio usando un elenco di argomenti variabile.

void FormatV(PCXSTR pszFormat, va_list args);

Parametri

pszFormat
Punta alla stringa del controllo formato. Verrà analizzata per gli inserimenti e formattati di conseguenza. La stringa di formato è simile alle stringhe di formato della funzione printfdi runtime, ad eccezione del fatto che consente l'inserimento dei parametri in un ordine arbitrario.

args
Puntatore a un elenco di argomenti.

Osservazioni:

Scrive una stringa formattata e un elenco di argomenti in una CStringT stringa nello stesso modo in cui vsprintf_s i dati vengono formattati in una matrice di caratteri in stile C.

Esempio

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`

Imposta la stringa sul valore della variabile di ambiente specificata.

BOOL GetEnvironmentVariable(PCXSTR pszVar);

Parametri

pszVar
Puntatore a una stringa con terminazione Null che specifica la variabile di ambiente.

Valore restituito

Diverso da zero se ha esito positivo; in caso contrario 0.

Osservazioni:

Recupera il valore della variabile specificata dal blocco di ambiente del processo chiamante. Il valore è sotto forma di stringa con terminazione Null di caratteri.

Esempio

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

Inserisce un singolo carattere o una sottostringa in corrispondenza dell'indice specificato all'interno della stringa.

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

Parametri

iIndex
Indice del carattere prima del quale verrà eseguito l'inserimento.

psz
Puntatore alla sottostringa da inserire.

ch
Carattere da inserire.

Valore restituito

Lunghezza della stringa modificata.

Osservazioni:

Il iIndex parametro identifica il primo carattere che verrà spostato per liberare spazio per il carattere o la sottostringa. Se nIndex è zero, l'inserimento verrà eseguito prima dell'intera stringa. Se nIndex è maggiore della lunghezza della stringa, la funzione concatena la stringa presente e il nuovo materiale fornito da ch o psz.

Esempio

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

Estrae i caratteri più nCount a sinistra da questo CStringT oggetto e restituisce una copia della sottostringa estratta.

CStringT Left(int nCount) const;

Parametri

nCount
Il numero di caratteri da estrarre da questo oggetto CStringT.

Valore restituito

Oggetto CStringT contenente una copia dell'intervallo specificato. L'oggetto CStringT restituito può essere vuoto.

Osservazioni:

Se nCount supera la lunghezza della stringa, viene estratta l'intera stringa. Left è simile alla funzione di base Left.

Per i set di caratteri a più byte (MBCS), nCount considera ogni sequenza a 8 bit come carattere, in modo che nCount restituisca il numero di caratteri a più byte moltiplicati per due.

Esempio

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

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

`CStringT::LoadString`

Legge una risorsa stringa di Windows, identificata da nID, in un oggetto esistente CStringT .

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

Parametri

hInstance
Handle per l'istanza del modulo.

nID
ID risorsa stringa di Windows.

wLanguageID
Lingua della risorsa stringa.

Valore restituito

Diverso da zero se il caricamento delle risorse è riuscito; in caso contrario, 0.

Osservazioni:

Carica la risorsa stringa (nID) dal modulo specificato (hInstance) usando la lingua specificata (wLanguage).

Esempio

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

CAtlString s;
s.LoadString(IDS_APP_TITLE);

`CStringT::MakeLower`

Converte l'oggetto CStringT in una stringa minuscola.

CStringT& MakeLower();

Valore restituito

Stringa minuscola risultante.

Esempio

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

CAtlString s(_T("ABC"));

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

`CStringT::MakeReverse`

Inverte l'ordine dei caratteri nell'oggetto CStringT .

CStringT& MakeReverse();

Valore restituito

Stringa invertita risultante.

Esempio

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

CAtlString s(_T("abc"));

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

`CStringT::MakeUpper`

Converte l'oggetto CStringT in una stringa maiuscola.

CStringT& MakeUpper();

Valore restituito

Stringa maiuscola risultante.

Osservazioni:

Esempio

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

CAtlString s(_T("abc"));

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

`CStringT::Mid`

Estrae una sottostringa di caratteri di lunghezza nCount da questo CStringT oggetto, a partire dalla posizione iFirst (in base zero).

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

Parametri

iFirst
Indice in base zero del primo carattere in questo CStringT oggetto da includere nella sottostringa estratta.

nCount
Il numero di caratteri da estrarre da questo oggetto CStringT. Se questo parametro non viene specificato, il resto della stringa viene estratto.

Valore restituito

Oggetto CStringT contenente una copia dell'intervallo specificato. L'oggetto CStringT restituito può essere vuoto.

Osservazioni:

La funzione restituisce una copia della sottostringa estratta. Mid è simile alla funzione Basic Mid (ad eccezione del fatto che gli indici in Basic sono basati su uno).

Per i set di caratteri multibyte (MBCS), nCount fa riferimento a ogni carattere a 8 bit, ovvero un byte iniziale e finale in un carattere multibyte viene conteggiato come due caratteri.

Esempio

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

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

`CStringT::OemToAnsi`

Converte tutti i caratteri in questo CStringT oggetto dal set di caratteri OEM al set di caratteri ANSI.

void OemToAnsi();

Osservazioni:

Questa funzione non è disponibile se _UNICODE è definita.

Esempio

Vedere l'esempio per CStringT::AnsiToOem.

`CStringT::operator =`

Assegna un nuovo valore alla stringa.

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

Parametri

strSrc
Oggetto CStringT da assegnare a questa stringa.

str
Riferimento a un oggetto CThisSimpleString.

bMFCDLL
Valore booleano che specifica se il progetto è una DLL MFC o meno.

BaseType
Tipo di base stringa.

var
Oggetto variant da assegnare a questa stringa.

ch
Carattere ANSI o Unicode da assegnare alla stringa.

pszSrc
Puntatore alla stringa originale assegnata.

Osservazioni:

L'operatore di assegnazione accetta un altro CStringT oggetto, un puntatore a caratteri o un singolo carattere. Le eccezioni di memoria possono verificarsi ogni volta che si usa questo operatore perché è possibile allocare una nuova risorsa di archiviazione.

Per informazioni su CThisSimpleString, vedere la sezione Osservazioni di CStringT::CStringT.

Nota

`CStringT::operator +`

Concatena due stringhe o un carattere e una stringa.

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

Parametri

ch1
Carattere ANSI o Unicode da concatenare con una stringa.

ch2
Carattere ANSI o Unicode da concatenare con una stringa.

str1
Oggetto CStringT da concatenare con una stringa o un carattere.

str2
Oggetto CStringT da concatenare con una stringa o un carattere.

psz1
Puntatore a una stringa con terminazione Null da concatenare con una stringa o un carattere.

psz2
Puntatore a una stringa da concatenare con una stringa o un carattere.

Osservazioni:

Esistono sette forme di overload della CStringT::operator+ funzione. La prima versione concatena due oggetti esistenti CStringT . I due successivi concatenano un CStringT oggetto e una stringa con terminazione Null. I due successivi concatenano un CStringT oggetto e un carattere ANSI. Gli ultimi due concatenano un CStringT oggetto e un carattere Unicode.

Nota

Esempio

// 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 +=`

Concatena i caratteri alla fine della stringa.

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

Parametri

str
Riferimento a un oggetto CThisSimpleString.

bMFCDLL
Valore booleano che specifica se il progetto è una DLL MFC o meno.

BaseType
Tipo di base stringa.

var
Oggetto variant da concatenare a questa stringa.

ch
Carattere ANSI o Unicode da concatenare con una stringa.

pszSrc
Puntatore alla stringa originale concatenata.

strSrc
Oggetto CStringT da concatenare a questa stringa.

Osservazioni:

L'operatore accetta un altro CStringT oggetto, un puntatore a caratteri o un singolo carattere. Le eccezioni di memoria possono verificarsi ogni volta che si usa questo operatore di concatenazione perché è possibile allocare una nuova risorsa di archiviazione per i caratteri aggiunti a questo CStringT oggetto.

Per informazioni su CThisSimpleString, vedere la sezione Osservazioni di CStringT::CStringT.

Nota

Esempio

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

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

`CStringT::operator ==`

Determina se due stringhe sono logicamente uguali.

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

Parametri

ch1
Carattere ANSI o Unicode per il confronto.

ch2
Carattere ANSI o Unicode per il confronto.

str1
Oggetto CStringT per il confronto.

str2
Oggetto CStringT per il confronto.

psz1
Puntatore a una stringa con terminazione Null per il confronto.

psz2
Puntatore a una stringa con terminazione Null per il confronto.

Osservazioni:

Verifica se una stringa o un carattere sul lato sinistro è uguale a una stringa o un carattere sul lato destro e restituisce TRUE o FALSE di conseguenza.

Esempio

// 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 !=`

Determina se due stringhe sono logicamente non uguali.

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

Parametri

ch1
Carattere ANSI o Unicode da concatenare con una stringa.

ch2
Carattere ANSI o Unicode da concatenare con una stringa.

str1
Oggetto CStringT per il confronto.

str2
Oggetto CStringT per il confronto.

psz1
Puntatore a una stringa con terminazione Null per il confronto.

psz2
Puntatore a una stringa con terminazione Null per il confronto.

Osservazioni:

Verifica se una stringa o un carattere sul lato sinistro non è uguale a una stringa o a un carattere a destra.

Esempio

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

Determina se la stringa sul lato sinistro dell'operatore è minore della stringa sul lato destro.

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

Parametri

str1
Oggetto CStringT per il confronto.

str2
Oggetto CStringT per il confronto.

psz1
Puntatore a una stringa con terminazione Null per il confronto.

psz2
Puntatore a una stringa con terminazione Null per il confronto.

Osservazioni:

Confronto lessicografico tra stringhe, carattere per carattere fino a:

Vengono trovati due caratteri corrispondenti non uguali e il risultato del loro confronto viene accettato come risultato del confronto tra le stringhe.
Non viene trovata alcuna disuguaglianza, ma una stringa include più caratteri dell'altra e la stringa più breve è considerata minore della stringa più lunga.
Non viene trovata alcuna disuguaglianza e le stringhe includono lo stesso numero di caratteri. Di conseguenza, le stringhe sono uguali.

Esempio

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

Determina se la stringa a sinistra dell'operatore è maggiore della stringa sul lato destro.

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

Parametri

str1
Oggetto CStringT per il confronto.

str2
Oggetto CStringT per il confronto.

psz1
Puntatore a una stringa con terminazione Null per il confronto.

psz2
Puntatore a una stringa con terminazione Null per il confronto.

Osservazioni:

Confronto lessicografico tra stringhe, carattere per carattere fino a:

Vengono trovati due caratteri corrispondenti non uguali e il risultato del loro confronto viene accettato come risultato del confronto tra le stringhe.
Non viene trovata alcuna disuguaglianza, ma una stringa include più caratteri dell'altra e la stringa più breve è considerata minore della stringa più lunga.
Non viene trovata alcuna disuguaglianza e le stringhe includono lo stesso numero di caratteri. Di conseguenza, le stringhe sono uguali.

Esempio

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

Determina se la stringa sul lato sinistro dell'operatore è minore o uguale alla stringa sul lato destro.

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

Parametri

str1
Oggetto CStringT per il confronto.

str2
Oggetto CStringT per il confronto.

psz1
Puntatore a una stringa con terminazione Null per il confronto.

psz2
Puntatore a una stringa con terminazione Null per il confronto.

Osservazioni:

Confronto lessicografico tra stringhe, carattere per carattere fino a:

Vengono trovati due caratteri corrispondenti non uguali e il risultato del loro confronto viene accettato come risultato del confronto tra le stringhe.
Non viene trovata alcuna disuguaglianza, ma una stringa include più caratteri dell'altra e la stringa più breve è considerata minore della stringa più lunga.
Non viene trovata alcuna disuguaglianza e le stringhe includono lo stesso numero di caratteri. Di conseguenza, le stringhe sono uguali.

Esempio

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

Determina se la stringa a sinistra dell'operatore è maggiore o uguale alla stringa sul lato destro.

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

Parametri

str1
Oggetto CStringT per il confronto.

str2
Oggetto CStringT per il confronto.

psz1
Puntatore a una stringa per il confronto.

psz2
Puntatore a una stringa per il confronto.

Osservazioni:

Confronto lessicografico tra stringhe, carattere per carattere fino a:

Vengono trovati due caratteri corrispondenti non uguali e il risultato del loro confronto viene accettato come risultato del confronto tra le stringhe.
Non viene trovata alcuna disuguaglianza, ma una stringa include più caratteri dell'altra e la stringa più breve è considerata minore della stringa più lunga.
Non viene trovata alcuna disuguaglianza e le stringhe includono lo stesso numero di caratteri. Di conseguenza, le stringhe sono uguali.

Esempio

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

Rimuove tutte le istanze del carattere specificato dalla stringa.

int Remove(XCHAR chRemove);

Parametri

chRemove
Carattere da rimuovere da una stringa.

Valore restituito

Numero di caratteri rimossi dalla stringa. Zero se la stringa non viene modificata.

Osservazioni:

I confronti per il carattere fanno distinzione tra maiuscole e minuscole.

Esempio

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

Sono disponibili due versioni di Replace. La prima versione sostituisce una o più copie di una sottostringa usando un'altra sottostringa. Entrambe le sottostringhe sono con terminazione Null. La seconda versione sostituisce una o più copie di un carattere usando un altro carattere. Entrambe le versioni operano sui dati di tipo carattere archiviati in CStringT.

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

Parametri

pszOld
Puntatore a una stringa con terminazione Null da sostituire con pszNew.

pszNew
Puntatore a una stringa con terminazione Null che sostituisce pszOld.

chOld
Carattere da sostituire con chNew.

chNew
Carattere che sostituisce chOld.

Valore restituito

Restituisce il numero di istanze sostituite del carattere o della sottostringa oppure zero se la stringa non viene modificata.

Osservazioni:

Replace può modificare la lunghezza della stringa perché pszNew e pszOld non deve essere la stessa lunghezza e diverse copie della sottostringa precedente possono essere modificate in quella nuova. La funzione esegue una corrispondenza con distinzione tra maiuscole e minuscole.

Esempi di CStringT istanze sono CString, CStringAe CStringW.

Per CStringA, Replace funziona con caratteri ANSI o multibyte (MBCS). Per CStringW, Replace funziona con caratteri wide.

Per CString, il tipo di dati carattere viene selezionato in fase di compilazione, in base al fatto che le costanti nella tabella seguente siano definite.

Costante definita	Tipo di dati Character
`_UNICODE`	Caratteri wide
`_MBCS`	Caratteri a più byte
Nessuno	Caratteri a byte singolo
Entrambi	Non definito

Esempio

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

Cerca nell'oggetto CStringT l'ultima corrispondenza di un carattere.

int ReverseFind(XCHAR ch) const throw();

Parametri

ch
Carattere da cercare.

Valore restituito

Indice in base zero dell'ultimo carattere in questo CStringT oggetto che corrisponde al carattere richiesto oppure -1 se il carattere non viene trovato.

Osservazioni:

La funzione è simile alla funzione strrchrdi runtime .

Esempio

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

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

`CStringT::Right`

Estrae i caratteri dell'ultimo oggetto ( ovvero più a destra) nCount da questo CStringT oggetto e restituisce una copia della sottostringa estratta.

CStringT Right(int nCount) const;

Parametri

nCount
Il numero di caratteri da estrarre da questo oggetto CStringT.

Valore restituito

Oggetto CStringT contenente una copia dell'intervallo specificato. L'oggetto restituito CStringT può essere vuoto.

Osservazioni:

Se nCount supera la lunghezza della stringa, viene estratta l'intera stringa. Right è simile alla funzione Basic Right (ad eccezione del fatto che gli indici in Basic sono in base zero).

Per i set di caratteri multibyte (MBCS), nCount fa riferimento a ogni carattere a 8 bit, ovvero un byte iniziale e finale in un carattere multibyte viene conteggiato come due caratteri.

Esempio

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

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

`CStringT::SetSysString`

Rialloca l'oggetto BSTR a cui pbstr punta e copia il contenuto dell'oggetto CStringT in esso, incluso il NULL carattere .

BSTR SetSysString(BSTR* pbstr) const;

Parametri

pbstr
Puntatore a una stringa di caratteri.

Valore restituito

La nuova stringa.

Osservazioni:

A seconda del contenuto dell'oggetto CStringT , il valore dell'oggetto BSTR a cui viene fatto pbstr riferimento può cambiare. La funzione genera un'eccezione CMemoryException se esiste memoria insufficiente.

Questa funzione viene in genere usata per modificare il valore delle stringhe passate per riferimento per Automazione.

Esempio

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`

Estrae caratteri dalla stringa, a partire dal primo carattere, che non si trovano nel set di caratteri identificati da pszCharSet.

CStringT SpanExcluding(PCXSTR pszCharSet) const;

Parametri

pszCharSet
Stringa interpretata come set di caratteri.

Valore restituito

Sottostringa che contiene caratteri nella stringa che non sono in pszCharSet, a partire dal primo carattere nella stringa e che termina con il primo carattere trovato anche pszCharSet nella stringa , ovvero a partire dal primo carattere nella stringa e fino a ma escludendo il primo carattere nella stringa trovata pszCharSet. Restituisce l'intera stringa se non viene trovato alcun carattere pszCharSet nella stringa.

Osservazioni:

SpanExcluding estrae e restituisce tutti i caratteri precedenti alla prima occorrenza di un carattere da pszCharSet (in altre parole, il carattere da pszCharSet e tutti i caratteri successivi alla stringa, non vengono restituiti). Se nella stringa non viene trovato alcun carattere pszCharSet , SpanExcluding restituisce l'intera stringa.

Esempio

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

Estrae caratteri dalla stringa, a partire dal primo carattere, che si trovano nel set di caratteri identificati da pszCharSet.

CStringT SpanIncluding(PCXSTR pszCharSet) const;

Parametri

pszCharSet
Stringa interpretata come set di caratteri.

Valore restituito

Sottostringa che contiene caratteri nella stringa che si trovano in pszCharSet, a partire dal primo carattere nella stringa e che termina quando si trova un carattere nella stringa che non è presente in pszCharSet. SpanIncluding restituisce una sottostringa vuota se il primo carattere nella stringa non è incluso nel set specificato.

Osservazioni:

Se il primo carattere della stringa non è incluso nel set di caratteri, SpanIncluding restituisce una stringa vuota. In caso contrario, restituisce una sequenza di caratteri consecutivi presenti nel set.

Esempio

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

Trova il token successivo in una stringa di destinazione

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

Parametri

pszTokens
Stringa contenente delimitatori di token. L'ordine di questi delimitatori non è importante.

iStart
Indice in base zero per iniziare la ricerca.

Valore restituito

Oggetto CStringT contenente il valore del token corrente.

Osservazioni:

La Tokenize funzione trova il token successivo nella stringa di destinazione. Il set di caratteri in pszTokens specifica i possibili delimitatori del token da trovare. In ogni chiamata alla Tokenize funzione inizia da iStart, ignora i delimitatori iniziali e restituisce un CStringT oggetto contenente il token corrente, ovvero la stringa di caratteri fino al carattere delimitatore successivo. Il valore di iStart viene aggiornato in modo che sia la posizione successiva al carattere delimitatore finale oppure -1 se è stata raggiunta la fine della stringa. È possibile suddividere più token dal resto della stringa di destinazione da una serie di chiamate a Tokenize, usando iStart per tenere traccia del punto in cui nella stringa deve essere letto il token successivo. Quando non sono presenti più token, la funzione restituirà una stringa vuota e iStart verrà impostata su -1.

A differenza delle funzioni CRT tokenize come strtok_s, _strtok_s_l, _wcstok_s_lwcstok_s, _mbstok_s, , _mbstok_s_l, Tokenize non modifica la stringa di destinazione.

Esempio

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

L'output di questo esempio è il seguente:

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

`CStringT::Trim`

Taglia i caratteri iniziali e finali dalla stringa.

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

Parametri

chTarget
Carattere di destinazione da tagliare.

pszTargets
Puntatore a una stringa contenente i caratteri di destinazione da tagliare. Tutte le occorrenze iniziali e finali di caratteri in pszTargets verranno tagliate dall'oggetto CStringT .

Valore restituito

Restituisce la stringa tagliata.

Osservazioni:

Rimuove tutte le occorrenze iniziali e finali di una delle seguenti:

Carattere specificato da chTarget.
Tutti i caratteri trovati nella stringa specificata da pszTargets.
Spazi vuoti.

Esempio

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

L'output di questo esempio è il seguente:

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

`CStringT::TrimLeft`

Taglia i caratteri iniziali dalla stringa.

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

Parametri

chTarget
Carattere di destinazione da tagliare.

pszTargets
Puntatore a una stringa contenente i caratteri di destinazione da tagliare. Tutte le occorrenze iniziali di caratteri in pszTargets verranno tagliate dall'oggetto CStringT .

Valore restituito

Stringa tagliata risultante.

Osservazioni:

Rimuove tutte le occorrenze iniziali e finali di una delle seguenti:

Carattere specificato da chTarget.
Tutti i caratteri trovati nella stringa specificata da pszTargets.
Spazi vuoti.

Esempio

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

Taglia i caratteri finali dalla stringa.

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

Parametri

chTarget
Carattere di destinazione da tagliare.

pszTargets
Puntatore a una stringa contenente i caratteri di destinazione da tagliare. Tutte le occorrenze finali di caratteri in pszTargets verranno eliminate dall'oggetto CStringT .

Valore restituito

Restituisce l'oggetto CStringT contenente la stringa tagliata.

Osservazioni:

Rimuove le occorrenze finali di uno dei seguenti elementi:

Carattere specificato da chTarget.
Tutti i caratteri trovati nella stringa specificata da pszTargets.
Spazi vuoti.

La CStringT& TrimRight(XCHAR chTarget) versione accetta un parametro di carattere e rimuove tutte le copie di tale carattere dalla fine dei dati stringa CStringT . Inizia dalla fine della stringa e funziona verso il lato anteriore. Si arresta quando trova un carattere diverso o quando CStringT esaurisce i dati di tipo carattere.

La CStringT& TrimRight(PCXSTR pszTargets) versione accetta una stringa con terminazione Null che contiene tutti i diversi caratteri da cercare. Rimuove tutte le copie di tali caratteri nell'oggetto CStringT . Inizia alla fine della stringa e funziona verso il lato anteriore. Si arresta quando trova un carattere che non si trova nella stringa di destinazione o quando CStringT si esaurisce i dati di tipo carattere. Non tenta di associare l'intera stringa di destinazione a una sottostringa alla fine di CStringT.

La CStringT& TrimRight() versione non richiede parametri. Elimina tutti gli spazi vuoti finali dalla fine della CStringT stringa. Gli spazi vuoti possono essere interruzioni di riga, spazi o schede.

Esempio

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

Vedi anche

Grafico della gerarchia
Classi condivise ATL/MFC
CSimpleStringT Classe

Condividi tramite

Classe CStringT

Sintassi

Parametri

Membri

Costruttori pubblici

Metodi pubblici

Operatori

Osservazioni:

Tipi predefiniti CStringT

Gerarchia di ereditarietà

Requisiti

CStringT::AllocSysString

Valore restituito

Osservazioni:

Esempio

CStringT::AnsiToOem

Osservazioni:

Esempio

CStringT::AppendFormat

Parametri

Osservazioni:

Esempio

CStringT::Collate

Parametri

Valore restituito

Osservazioni:

CStringT::CollateNoCase

Parametri

Valore restituito

Osservazioni:

Esempio

CStringT::Compare

Parametri

Valore restituito

Osservazioni:

Esempio

CStringT::CompareNoCase

Parametri

Valore restituito

Osservazioni:

Esempio

CStringT::CStringT

Parametri

Osservazioni:

Esempio

CStringT::~CStringT

Osservazioni:

CStringT::Delete

Parametri

Valore restituito

Osservazioni:

Esempio

CStringT::Find

Parametri

Valore restituito

Osservazioni:

Esempio

CStringT::FindOneOf

Parametri

Valore restituito

Osservazioni:

Esempio

CStringT::Format

Parametri

Osservazioni:

Esempio

CStringT::FormatMessage

Parametri

Osservazioni:

Esempio

CStringT::FormatMessageV

Parametri

Osservazioni:

CStringT::FormatV

Parametri

Osservazioni:

Esempio

CStringT::GetEnvironmentVariable

Parametri

Classe `CStringT`

`CStringT::AllocSysString`

`CStringT::AnsiToOem`

`CStringT::AppendFormat`

`CStringT::Collate`

`CStringT::CollateNoCase`

`CStringT::Compare`

`CStringT::CompareNoCase`

`CStringT::CStringT`

`CStringT::~CStringT`

`CStringT::Delete`

`CStringT::Find`

`CStringT::FindOneOf`

`CStringT::Format`

`CStringT::FormatMessage`

`CStringT::FormatMessageV`

`CStringT::FormatV`

`CStringT::GetEnvironmentVariable`

`CStringT::Insert`

`CStringT::Left`

`CStringT::LoadString`

`CStringT::MakeLower`

`CStringT::MakeReverse`

`CStringT::MakeUpper`

`CStringT::Mid`

`CStringT::OemToAnsi`

`CStringT::operator =`

`CStringT::operator +`

`CStringT::operator +=`

`CStringT::operator ==`

`CStringT::operator !=`

`CStringT::operator <`

`CStringT::operator >`

`CStringT::operator <=`

`CStringT::operator >=`