Classe CSimpleStringT
Questa classe rappresenta un CSimpleStringT oggetto .
Sintassi
template <typename BaseType>
class CSimpleStringT
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).
Membri
Typedef pubblici
| Nome | Descrizione |
|---|---|
CSimpleStringT::PCXSTR |
Puntatore a una stringa costante. |
CSimpleStringT::PXSTR |
Puntatore a una stringa. |
Costruttori pubblici
| Nome | Descrizione |
|---|---|
CSimpleStringT::CSimpleStringT |
Costruisce oggetti CSimpleStringT in vari modi. |
CSimpleStringT::~CSimpleStringT |
Distruttore. |
Metodi pubblici
| Nome | Descrizione |
|---|---|
CSimpleStringT::Append |
Accoda un CSimpleStringT oggetto a un oggetto esistente CSimpleStringT . |
CSimpleStringT::AppendChar |
Aggiunge un carattere a un oggetto esistente CSimpleStringT . |
CSimpleStringT::CopyChars |
Copia un carattere o un carattere in un'altra stringa. |
CSimpleStringT::CopyCharsOverlapped |
Copia un carattere o un carattere in un'altra stringa in cui si sovrappongono i buffer. |
CSimpleStringT::Empty |
Forza la lunghezza di una stringa pari a zero. |
CSimpleStringT::FreeExtra |
Libera qualsiasi memoria aggiuntiva allocata in precedenza dall'oggetto stringa. |
CSimpleStringT::GetAllocLength |
Recupera la lunghezza allocata di un CSimpleStringT oggetto . |
CSimpleStringT::GetAt |
Restituisce il carattere in una determinata posizione. |
CSimpleStringT::GetBuffer |
Restituisce un puntatore ai caratteri in un oggetto CSimpleStringT. |
CSimpleStringT::GetBufferSetLength |
Restituisce un puntatore ai caratteri in un CSimpleStringToggetto , troncando alla lunghezza specificata. |
CSimpleStringT::GetLength |
Restituisce il numero di caratteri in un CSimpleStringT oggetto . |
CSimpleStringT::GetManager |
Recupera il gestore della memoria dell'oggetto CSimpleStringT . |
CSimpleStringT::GetString |
Recupera la stringa di caratteri |
CSimpleStringT::IsEmpty |
Verifica se un CSimpleStringT oggetto non contiene caratteri. |
CSimpleStringT::LockBuffer |
Disabilita il conteggio dei riferimenti e protegge la stringa nel buffer. |
CSimpleStringT::Preallocate |
Alloca una quantità specifica di memoria per il buffer di caratteri. |
CSimpleStringT::ReleaseBuffer |
Rilascia il controllo del buffer restituito da GetBuffer. |
CSimpleStringT::ReleaseBufferSetLength |
Rilascia il controllo del buffer restituito da GetBuffer. |
CSimpleStringT::SetAt |
Imposta un carattere in una determinata posizione. |
CSimpleStringT::SetManager |
Imposta il gestore della memoria di un CSimpleStringT oggetto . |
CSimpleStringT::SetString |
Imposta la stringa di un CSimpleStringT oggetto . |
CSimpleStringT::StringLength |
Restituisce il numero di caratteri nella stringa specificata. |
CSimpleStringT::Truncate |
Tronca la stringa a una lunghezza specificata. |
CSimpleStringT::UnlockBuffer |
Abilita il conteggio dei riferimenti e rilascia la stringa nel buffer. |
Operatori pubblici
| Nome | Descrizione |
|---|---|
CSimpleStringT::operator PCXSTR |
Accede direttamente ai caratteri archiviati in un CSimpleStringT oggetto come stringa di tipo C. |
CSimpleStringT::operator[] |
Restituisce il carattere in una determinata posizione, ovvero la sostituzione dell'operatore per GetAt. |
CSimpleStringT::operator += |
Concatena una nuova stringa alla fine di una stringa esistente. |
CSimpleStringT::operator = |
Assegna un nuovo valore a un CSimpleStringT oggetto . |
Osservazioni:
CSimpleStringT è la classe di base per le varie classi di stringhe supportate da Visual C++. Offre un supporto minimo per la gestione della memoria dell'oggetto stringa e la modifica di base del buffer. Per oggetti stringa più avanzati, vedere CStringT Class.
Requisiti
Intestazione:atlsimpstr.h
CSimpleStringT::Append
Accoda un CSimpleStringT oggetto a un oggetto esistente CSimpleStringT .
Sintassi
void Append(const CSimpleStringT& strSrc);
void Append(PCXSTR pszSrc, int nLength);
void Append(PCXSTR pszSrc);
Parametri
strSrc
Oggetto CSimpleStringT da accodare.
pszSrc
Puntatore a una stringa contenente i caratteri da aggiungere.
nLength
Numero di caratteri da accodare.
Osservazioni:
Chiamare questo metodo per accodare un oggetto esistente CSimpleStringT a un altro CSimpleStringT oggetto.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::Append.
CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str1(pMgr), str2(pMgr);
str1.SetString(_T("Soccer is"));
str2.SetString(_T(" an elegant game"));
str1.Append(str2);
ASSERT(_tcscmp(str1, _T("Soccer is an elegant game")) == 0);
CSimpleStringT::AppendChar
Aggiunge un carattere a un oggetto esistente CSimpleStringT .
Sintassi
void AppendChar(XCHAR ch);
Parametri
ch
Carattere da aggiungere
Osservazioni:
Chiamare questa funzione per aggiungere il carattere specificato alla fine di un oggetto esistente CSimpleStringT .
CSimpleStringT::CopyChars
Copia un carattere o un carattere in un CSimpleStringT oggetto .
Sintassi
static void CopyChars(
XCHAR* pchDest,
const XCHAR* pchSrc,
int nChars) throw();
static void CopyChars(
XCHAR* pchDest,
size_t nDestLen,
const XCHAR* pchSrc,
int nChars) throw();
Parametri
pchDest
Puntatore a una stringa di caratteri.
nDestLen
Dimensioni del buffer di pchDest
pchSrc
Puntatore a una stringa contenente i caratteri da copiare.
nChars
Numero di pchSrc caratteri da copiare.
Osservazioni:
Chiamare questo metodo per copiare caratteri da pchSrc alla pchDest stringa.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::CopyChars.
CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str(_T("xxxxxxxxxxxxxxxxxxx"), 20, pMgr);
const TCHAR* pszSrc = _T("Hello world!");
_tprintf_s(_T("%s\n"), str);
str.CopyChars(str.GetBuffer(), 20, pszSrc, 12);
_tprintf_s(_T("%s\n"), str);
L'output di questo esempio è il seguente:
xxxxxxxxxxxxxxxxxxx
Hello world!xxxxxxx
CSimpleStringT::CopyCharsOverlapped
Copia un carattere o un carattere in un CSimpleStringT oggetto .
Sintassi
static void CopyCharsOverlapped(
XCHAR* pchDest,
const XCHAR* pchSrc,
int nChars) throw();
Parametri
pchDest
Puntatore a una stringa di caratteri.
pchSrc
Puntatore a una stringa contenente i caratteri da copiare.
nChars
Numero di pchSrc caratteri da copiare.
Osservazioni:
Chiamare questo metodo per copiare caratteri da pchSrc alla pchDest stringa. A differenza di CopyChars, CopyCharsOverlapped fornisce un metodo sicuro per la copia da buffer di caratteri che potrebbero essere sovrapposti.
Esempio
Vedere l'esempio per CSimpleStringT::CopyCharso il codice sorgente per CSimpleStringT::SetString (disponibile in atlsimpstr.h).
CSimpleStringT::CSimpleStringT
Costruisce un oggetto CSimpleStringT.
Sintassi
CSimpleStringT(const XCHAR* pchSrc, int nLength, IAtlStringMgr* pStringMgr);
CSimpleStringT(PCXSTR pszSrc, IAtlStringMgr* pStringMgr);
CSimpleStringT(const CSimpleStringT& strSrc);
explicit CSimpleStringT(IAtlStringMgr* pStringMgr) throw();
Parametri
strSrc
Oggetto esistente CSimpleStringT da copiare in questo CSimpleStringT oggetto.
pchSrc
Puntatore a una matrice di caratteri di lunghezza nLength, non terminazione Null.
pszSrc
Stringa con terminazione Null da copiare in questo CSimpleStringT oggetto.
nLength
Conteggio del numero di caratteri in pch.
pStringMgr
Puntatore al gestore della memoria dell'oggetto CSimpleStringT . Per altre informazioni sulla IAtlStringMgr gestione della memoria per CSimpleStringT, vedere Gestione della memoria e CStringT.
Osservazioni:
Costruisce un nuovo oggetto CSimpleStringT. Poiché i costruttori copiano i dati di input in una nuova risorsa di archiviazione allocata, possono verificarsi eccezioni di memoria.
Esempio
Nell'esempio seguente viene illustrato l'uso di CSimpleStringT::CSimpleStringT tramite ATL typedefCSimpleString. CSimpleString è una specializzazione comunemente usata del modello CSimpleStringTdi classe .
CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString s1(pMgr);
// Empty string
CSimpleString s2(_T("cat"), pMgr);
// From a C string literal
CSimpleString s3(s2);
// Copy constructor
CSimpleString s4(s2 + _T(" ") + s3);
// From a string expression
CSimpleString s5(_T("xxxxxx"), 6, pMgr);
// s5 = "xxxxxx"
CSimpleStringT::Empty
Rende questo CSimpleStringT oggetto una stringa vuota e libera la memoria in base alle esigenze.
Sintassi
void Empty() throw();
Osservazioni:
Per altre informazioni, vedere Stringhe: CString Pulizia eccezioni.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::Empty.
CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString s(pMgr);
ASSERT(s.IsEmpty());
CSimpleStringT::FreeExtra
Libera qualsiasi memoria aggiuntiva allocata in precedenza dalla stringa, ma non è più necessaria.
Sintassi
void FreeExtra();
Osservazioni:
Ciò dovrebbe ridurre il sovraccarico di memoria utilizzato dall'oggetto stringa. Il metodo rialloca il buffer alla lunghezza esatta restituita da GetLength.
Esempio
CAtlString basestr;
IAtlStringMgr* pMgr;
pMgr= basestr.GetManager();
ASSERT(pMgr != NULL);
// Create a CSimpleString with 28 characters
CSimpleString str(_T("Many sports are fun to play."), 28, pMgr);
_tprintf_s(_T("Alloc length is %d, String length is %d\n"),
str.GetAllocLength(), str.GetLength());
// Assigning a smaller string won't cause CSimpleString to free its
// memory, because it assumes the string will grow again anyway.
str = _T("Soccer is best!");
_tprintf_s(_T("Alloc length is %d, String length is %d\n"),
str.GetAllocLength(), str.GetLength());
// This call forces CSimpleString to release the extra
// memory it doesn't need.
str.FreeExtra();
_tprintf_s(_T("Alloc length is %d, String length is %d\n"),
str.GetAllocLength(), str.GetLength());
L'output di questo esempio è il seguente:
Alloc length is 1031, String length is 1024
Alloc length is 1031, String length is 15
Alloc length is 15, String length is 15
CSimpleStringT::GetAllocLength
Recupera la lunghezza allocata di un CSimpleStringT oggetto .
Sintassi
int GetAllocLength() const throw();
Valore restituito
Numero di caratteri allocati per questo oggetto.
Osservazioni:
Chiamare questo metodo per determinare il numero di caratteri allocati per questo CSimpleStringT oggetto. Vedere FreeExtra per un esempio di chiamata a questa funzione.
CSimpleStringT::GetAt
Restituisce un carattere da un CSimpleStringT oggetto .
Sintassi
XCHAR GetAt(int iChar) const;
Parametri
iChar
Indice in base zero del carattere nell'oggetto CSimpleStringT . Il iChar parametro deve essere maggiore o uguale a 0 e minore del valore restituito da GetLength. In caso contrario, GetAt genererà un'eccezione.
Valore restituito
Oggetto XCHAR contenente il carattere in corrispondenza della posizione specificata nella stringa.
Osservazioni:
Chiamare questo metodo per restituire il carattere specificato da iChar. L'operatore di indice di overload ([]) è un pratico alias per GetAt. Il carattere di terminazione Null è indirizzabile senza generare un'eccezione tramite GetAt. Tuttavia, non viene conteggiato da GetLengthe il valore restituito è 0.
Esempio
Nell'esempio seguente viene illustrato come usare CSimpleStringT::GetAt.
CSimpleString s(_T("abcdef"), pMgr);
ASSERT(s.GetAt(2) == _T('c'));
CSimpleStringT::GetBuffer
Restituisce un puntatore al buffer di caratteri interno per l'oggetto CSimpleStringT .
Sintassi
PXSTR GetBuffer(int nMinBufferLength);
PXSTR GetBuffer();
Parametri
nMinBufferLength
Numero minimo di caratteri che il buffer di caratteri può contenere. Questo valore non include spazio per un carattere di terminazione Null.
Se nMinBufferLength è maggiore della lunghezza del buffer corrente, GetBuffer elimina definitivamente il buffer corrente, lo sostituisce con un buffer delle dimensioni richieste e reimposta il conteggio dei riferimenti all'oggetto su zero. Se in precedenza è stato chiamato LockBuffer su questo buffer, si perde il blocco del buffer.
Valore restituito
Puntatore PXSTR al buffer di caratteri (con terminazione Null) dell'oggetto.
Osservazioni:
Chiamare questo metodo per restituire il contenuto del buffer dell'oggetto CSimpleStringT . L'oggetto restituito PXSTR non è una costante e pertanto consente la modifica diretta del CSimpleStringT contenuto.
Se si usa il puntatore restituito da GetBuffer per modificare il contenuto della stringa, è necessario chiamare ReleaseBuffer per aggiornare lo stato interno di prima di CSimpleStringT utilizzare altri CSimpleStringT metodi.
L'indirizzo restituito da GetBuffer potrebbe non essere valido dopo la chiamata a ReleaseBuffer perché le operazioni aggiuntive CSimpleStringT possono causare la riallocazione del CSimpleStringT buffer. Il buffer non viene riallocato se non si modifica la lunghezza di CSimpleStringT.
La memoria del buffer viene liberata automaticamente quando l'oggetto CSimpleStringT viene eliminato definitivamente.
Se si tiene traccia della lunghezza della stringa manualmente, non è consigliabile aggiungere il carattere Null di terminazione. Tuttavia, è necessario specificare la lunghezza finale della stringa quando si rilascia il buffer con ReleaseBuffer. Se si aggiunge un carattere Null di terminazione, è necessario passare -1 (impostazione predefinita) per la lunghezza. ReleaseBuffer determina quindi la lunghezza del buffer.
Se la memoria non è sufficiente per soddisfare la GetBuffer richiesta, questo metodo genera un'eccezione CMemoryException*.
Esempio
CSimpleString s(_T("abcd"), pMgr);
LPTSTR pBuffer = s.GetBuffer(10);
int sizeOfBuffer = s.GetAllocLength();
// Directly access CSimpleString buffer
_tcscpy_s(pBuffer, sizeOfBuffer, _T("Hello"));
ASSERT(_tcscmp(s, _T("Hello")) == 0);
s.ReleaseBuffer();
CSimpleStringT::GetBufferSetLength
Restituisce un puntatore al buffer di caratteri interno per l'oggetto CSimpleStringT , troncando o aumentandone la lunghezza, se necessario, per corrispondere esattamente alla lunghezza specificata in nLength.
Sintassi
PXSTR GetBufferSetLength(int nLength);
Parametri
nLength
Dimensione esatta del CSimpleStringT buffer di caratteri in caratteri.
Valore restituito
Puntatore PXSTR al buffer di caratteri (con terminazione Null) dell'oggetto.
Osservazioni:
Chiamare questo metodo per recuperare una lunghezza specificata del buffer interno dell'oggetto CSimpleStringT . Il puntatore restituito PXSTR non const è e pertanto consente la modifica diretta del CSimpleStringT contenuto.
Se si usa il puntatore restituito da GetBufferSetLength per modificare il contenuto della stringa, chiamare ReleaseBuffer per aggiornare lo stato interno di prima di CSimpleStringT usare altri CSimpleStringT metodi.
L'indirizzo restituito da GetBufferSetLength potrebbe non essere valido dopo la chiamata a ReleaseBuffer perché le operazioni aggiuntive CSimpleStringT possono causare la riallocazione del CSimpleStringT buffer. Il buffer non viene riassegnato se non si modifica la lunghezza di CSimpleStringT.
La memoria del buffer viene liberata automaticamente quando l'oggetto CSimpleStringT viene eliminato definitivamente.
Se si tiene traccia della lunghezza della stringa manualmente, non aggiungere il carattere Null di terminazione. È necessario specificare la lunghezza finale della stringa quando si rilascia il buffer usando ReleaseBuffer. Se si aggiunge un carattere Null di terminazione quando si chiama ReleaseBuffer, passare -1 (impostazione predefinita) per la lunghezza a ReleaseBuffere ReleaseBuffer si eseguirà un strlen sul buffer per determinarne la lunghezza.
Per altre informazioni sul conteggio dei riferimenti, vedere gli articoli seguenti:
- Gestione delle durate degli oggetti tramite il conteggio dei riferimenti in Windows SDK.
- Implementazione del conteggio dei riferimenti in Windows SDK.
- Regole per la gestione dei conteggi dei riferimenti in Windows SDK.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::GetBufferSetLength.
CSimpleString str(pMgr);
LPTSTR pstr = str.GetBufferSetLength(3);
pstr[0] = _T('C');
pstr[1] = _T('u');
pstr[2] = _T('p');
str.ReleaseBuffer();
str += _T(" soccer is best!");
ASSERT(_tcscmp(str, _T("Cup soccer is best!")) == 0);
CSimpleStringT::GetLength
Restituisce il numero di caratteri nell'oggetto CSimpleStringT .
Sintassi
int GetLength() const throw();
Valore restituito
Conteggio dei caratteri nella stringa.
Osservazioni:
Chiamare questo metodo per restituire il numero di caratteri nell'oggetto . Il conteggio non include un carattere di terminazione Null.
Per i set di caratteri multibyte (MBCS), GetLength conta ogni carattere a 8 bit, ovvero un byte iniziale e finale in un carattere multibyte viene conteggiato come due byte. Vedere FreeExtra per un esempio di chiamata a questa funzione.
CSimpleStringT::GetManager
Recupera il gestore della memoria dell'oggetto CSimpleStringT .
Sintassi
IAtlStringMgr* GetManager() const throw();
Valore restituito
Puntatore al gestore della memoria per l'oggetto CSimpleStringT .
Osservazioni:
Chiamare questo metodo per recuperare la gestione della memoria utilizzata dall'oggetto CSimpleStringT . Per altre informazioni sui gestori di memoria e sugli oggetti stringa, vedere Gestione della memoria e CStringT.
CSimpleStringT::GetString
Recupera la stringa di caratteri.
Sintassi
PCXSTR GetString() const throw();
Valore restituito
Puntatore a una stringa di caratteri con terminazione Null.
Osservazioni:
Chiamare questo metodo per recuperare la stringa di caratteri associata all'oggetto CSimpleStringT .
Nota
Il puntatore restituito PCXSTR è const e non consente la modifica diretta del CSimpleStringT contenuto.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::GetString.
CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str(pMgr);
str += _T("Cup soccer is best!");
_tprintf_s(_T("%s"), str.GetString());
L'output di questo esempio è il seguente:
Cup soccer is best!
CSimpleStringT::IsEmpty
Verifica un CSimpleStringT oggetto per la condizione vuota.
Sintassi
bool IsEmpty() const throw();
Valore restituito
Restituisce TRUE se l'oggetto CSimpleStringT ha una lunghezza pari a 0; in caso contrario FALSE, .
Osservazioni:
Chiamare questo metodo per determinare se l'oggetto contiene una stringa vuota.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::IsEmpty.
CSimpleString s(pMgr);
ASSERT(s.IsEmpty());
CSimpleStringT::LockBuffer
Disabilita il conteggio dei riferimenti e protegge la stringa nel buffer.
Sintassi
PXSTR LockBuffer();
Valore restituito
Puntatore a un CSimpleStringT oggetto o a una stringa con terminazione Null.
Osservazioni:
Chiamare questo metodo per bloccare il buffer dell'oggetto CSimpleStringT . LockBufferChiamando , si crea una copia della stringa, con -1 per il conteggio dei riferimenti. Quando il valore del conteggio dei riferimenti è -1, la stringa nel buffer viene considerata in uno stato "bloccato". In uno stato bloccato, la stringa è protetta in due modi:
Nessun'altra stringa può ottenere un riferimento ai dati nella stringa bloccata, anche se tale stringa viene assegnata alla stringa bloccata.
La stringa bloccata non fa mai riferimento a un'altra stringa, anche se tale altra stringa viene copiata nella stringa bloccata.
Bloccando la stringa nel buffer, assicurarsi che il blocco esclusivo della stringa sul buffer rimanga intatto.
Al termine LockBufferdi , chiamare UnlockBuffer per reimpostare il conteggio dei riferimenti su 1.
Nota
Se si chiama GetBuffer su un buffer bloccato e si imposta il GetBuffer parametro nMinBufferLength su maggiore della lunghezza del buffer corrente, si perderà il blocco del buffer. Tale chiamata a GetBuffer elimina definitivamente il buffer corrente, la sostituisce con un buffer delle dimensioni richieste e reimposta il conteggio dei riferimenti su zero.
Per altre informazioni sul conteggio dei riferimenti, vedere gli articoli seguenti:
Gestione delle durate degli oggetti tramite il conteggio dei riferimenti in Windows SDK
Implementazione del conteggio dei riferimenti in Windows SDK
Regole per la gestione dei conteggi dei riferimenti in Windows SDK
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::LockBuffer.
CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str(_T("Hello"), pMgr);
TCHAR ch;
str.LockBuffer();
ch = str.GetAt(2);
_tprintf_s(_T("%c"), ch);
str.UnlockBuffer();
L'output di questo esempio è il seguente:
l
CSimpleStringT::operator[]
Chiamare questa funzione per accedere a un singolo carattere della matrice di caratteri.
Sintassi
XCHAR operator[](int iChar) const;
Parametri
iChar
Indice in base zero di un carattere nella stringa.
Osservazioni:
L'operatore di indice di overload ([]) restituisce un singolo carattere specificato dall'indice in base zero in iChar. Questo operatore è un sostituto pratico della GetAt funzione membro.
Nota
È possibile usare l'operatore pedice ([]) per ottenere il valore di un carattere in un CSimpleStringToggetto , ma non è possibile usarlo per modificare il valore di un carattere in un oggetto CSimpleStringT.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::operator [].
CSimpleString s(_T("abc"), pMgr);
ASSERT(s[1] == _T('b'));
CSimpleStringT::operator []
Chiamare questa funzione per accedere a un singolo carattere della matrice di caratteri.
Sintassi
XCHAR operator[](int iChar) const;
Parametri
iChar
Indice in base zero di un carattere nella stringa.
Osservazioni:
L'operatore di indice di overload ([]) restituisce un singolo carattere specificato dall'indice in base zero in iChar. Questo operatore è un sostituto pratico della GetAt funzione membro.
Nota
È possibile usare l'operatore pedice ([]) per ottenere il valore di un carattere in un CSimpleStringToggetto , ma non è possibile usarlo per modificare il valore di un carattere in un oggetto CSimpleStringT.
CSimpleStringT::operator +=
Unisce una nuova stringa o un nuovo carattere alla fine di una stringa esistente.
Sintassi
CSimpleStringT& operator +=(PCXSTR pszSrc);
CSimpleStringT& operator +=(const CSimpleStringT& strSrc);
template<int t_nSize>
CSimpleStringT& operator+=(const CStaticString< XCHAR, t_nSize >& strSrc);
CSimpleStringT& operator +=(char ch);
CSimpleStringT& operator +=(unsigned char ch);
CSimpleStringT& operator +=(wchar_t ch);
Parametri
pszSrc
Puntatore a una stringa con terminazione Null.
strSrc
Puntatore a un oggetto esistente CSimpleStringT .
ch
Il carattere da aggiungere.
Osservazioni:
L'operatore accetta un altro CSimpleStringT oggetto o un carattere. Si noti che 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 CSimpleStringT oggetto.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::operator +=.
CSimpleString str(_T("abc"), pMgr);
ASSERT(_tcscmp((str += _T("def")), _T("abcdef")) == 0);
CSimpleStringT::operator =
Assegna un nuovo valore a un CSimpleStringT oggetto .
Sintassi
CSimpleStringT& operator =(PCXSTR pszSrc);
CSimpleStringT& operator =(const CSimpleStringT& strSrc);
Parametri
pszSrc
Puntatore a una stringa con terminazione Null.
strSrc
Puntatore a un oggetto esistente CSimpleStringT .
Osservazioni:
Se la stringa di destinazione (sul lato sinistro) è già sufficientemente grande da archiviare i nuovi dati, non viene eseguita alcuna nuova allocazione di memoria. Si noti che le eccezioni di memoria possono verificarsi ogni volta che si usa l'operatore di assegnazione perché viene spesso allocata una nuova risorsa di archiviazione per contenere l'oggetto risultante CSimpleStringT .
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::operator =.
CSimpleString s1(pMgr), s2(pMgr);
// Empty CSimpleStringT objects
s1 = _T("cat");
// s1 = "cat"
ASSERT(_tcscmp(s1, _T("cat")) == 0);
s2 = s1; // s1 and s2 each = "cat"
ASSERT(_tcscmp(s2, _T("cat")) == 0);
s1 = _T("the ") + s1;
// Or expressions
ASSERT(_tcscmp(s1, _T("the cat")) == 0);
s1 = _T("x");
// Or just individual characters
ASSERT(_tcscmp(s1, _T("x")) == 0);
CSimpleStringT::operator PCXSTR
Accede direttamente ai caratteri archiviati in un CSimpleStringT oggetto come stringa di tipo C.
Sintassi
operator PCXSTR() const throw();
Valore restituito
Puntatore di caratteri ai dati della stringa.
Osservazioni:
Non vengono copiati caratteri; viene restituito solo un puntatore. Prestare attenzione a questo operatore. Se si modifica un CString oggetto dopo aver ottenuto il puntatore del carattere, è possibile che si verifichi una riallocazione della memoria che invalida il puntatore.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::operator PCXSTR.
// If the prototype of a function is known to the compiler,
// the PCXSTR cast operator may be invoked implicitly.
CSimpleString strSports(L"Soccer is Best!", pMgr);
WCHAR sz[1024];
wcscpy_s(sz, strSports);
// If the prototype isn't known or is a va_arg prototype,
// you must invoke the cast operator explicitly. For example,
// the va_arg part of a call to swprintf_s() needs the cast:
swprintf_s(sz, 1024, L"I think that %s!\n", (PCWSTR)strSports);
// While the format parameter is known to be an PCXSTR and
// therefore doesn't need the cast:
swprintf_s(sz, 1024, strSports);
// Note that some situations are ambiguous. This line will
// put the address of the strSports object to stdout:
wcout << strSports;
// while this line will put the content of the string out:
wcout << (PCWSTR)strSports;
CSimpleStringT::PCXSTR
Puntatore a una stringa costante.
Sintassi
typedef ChTraitsBase< BaseType >::PCXSTR PCXSTR;
CSimpleStringT::Preallocate
Alloca una quantità specifica di byte per l'oggetto CSimpleStringT .
Sintassi
void Preallocate( int nLength);
Parametri
nLength
Dimensione esatta del CSimpleStringT buffer di caratteri in caratteri.
Osservazioni:
Chiamare questo metodo per allocare una dimensione del buffer specifica per l'oggetto CSimpleStringT .
CSimpleStringT genera un'eccezione STATUS_NO_MEMORY se non è in grado di allocare spazio per il buffer di caratteri. Per impostazione predefinita, l'allocazione di memoria viene eseguita dalle funzioni HeapAlloc API WIN32 o HeapReAlloc.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::Preallocate.
CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str(pMgr);
_tprintf_s(_T("Allocated length: %d\n"), str.GetAllocLength());
str.Preallocate(100);
_tprintf_s(_T("Allocated length: %d\n"), str.GetAllocLength());
L'output di questo esempio è il seguente:
Allocated length: 0
Allocated length: 103
CSimpleStringT::PXSTR
Puntatore a una stringa.
Sintassi
typedef ChTraitsBase< BaseType >::PXSTR PXSTR;
CSimpleStringT::ReleaseBuffer
Rilascia il controllo del buffer allocato da GetBuffer.
Sintassi
void ReleaseBuffer(int nNewLength = -1);
Parametri
nNewLength
Nuova lunghezza della stringa in caratteri, senza contare un carattere di terminazione Null. Se la stringa è null terminata, il valore predefinito -1 imposta le CSimpleStringT dimensioni sulla lunghezza corrente della stringa.
Osservazioni:
Chiamare questo metodo per riallocare o liberare il buffer dell'oggetto stringa. Se si sa che la stringa nel buffer è null terminata, è possibile omettere l'argomento nNewLength . Se la stringa non ha terminazione Null, usare nNewLength per specificarne la lunghezza. L'indirizzo restituito da GetBuffer non è valido dopo la chiamata a ReleaseBuffer o qualsiasi altra CSimpleStringT operazione.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::ReleaseBuffer.
const int bufferSize = 1024;
CSimpleString s(_T("abc"), pMgr);
LPTSTR p = s.GetBuffer(bufferSize);
_tcscpy_s(p, bufferSize, _T("abc"));
// use the buffer directly
ASSERT(s.GetLength() == 3);
// String length = 3
s.ReleaseBuffer();
// Surplus memory released, p is now invalid.
ASSERT(s.GetLength() == 3);
// Length still 3
CSimpleStringT::ReleaseBufferSetLength
Rilascia il controllo del buffer allocato da GetBuffer.
Sintassi
void ReleaseBufferSetLength(int nNewLength);
Parametri
nNewLength
Lunghezza della stringa rilasciata
Osservazioni:
Questa funzione è funzionalmente simile a, ReleaseBuffer ad eccezione del fatto che deve essere passata una lunghezza valida per l'oggetto stringa.
CSimpleStringT::SetAt
Imposta un singolo carattere da un CSimpleStringT oggetto .
Sintassi
void SetAt(int iChar, XCHAR ch);
Parametri
iChar
Indice in base zero del carattere nell'oggetto CSimpleStringT . Il iChar parametro deve essere maggiore o uguale a 0 e minore del valore restituito da GetLength.
ch
Nuovo carattere.
Osservazioni:
Chiamare questo metodo per sovrascrivere il carattere che si trova in iChar. Questo metodo non ingrandisce la stringa se iChar supera i limiti della stringa esistente.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::SetAt.
CSimpleString s(_T("abcdef"), pMgr);
s.SetAt(1, _T('a'));
ASSERT(_tcscmp(s, _T("aacdef")) == 0);
CSimpleStringT::SetManager
Specifica il gestore della memoria dell'oggetto CSimpleStringT .
Sintassi
void SetManager(IAtlStringMgr* pStringMgr);
Parametri
pStringMgr
Puntatore al nuovo gestore di memoria.
Osservazioni:
Chiamare questo metodo per specificare un nuovo gestore di memoria utilizzato dall'oggetto CSimpleStringT . Per altre informazioni sui gestori di memoria e sugli oggetti stringa, vedere Gestione della memoria e CStringT.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::SetManager.
CSimpleString s(pMgr);
s.SetManager(pCustomMgr);
CSimpleStringT::SetString
Imposta la stringa di un CSimpleStringT oggetto .
Sintassi
void SetString(PCXSTR pszSrc, int nLength);
void SetString(PCXSTR pszSrc);
Parametri
pszSrc
Puntatore a una stringa con terminazione Null.
nLength
Conteggio del numero di caratteri in pszSrc.
Osservazioni:
Copiare una stringa nell'oggetto CSimpleStringT . SetString sovrascrive i dati di stringa meno recenti nel buffer.
Entrambe le versioni di SetString controllano se pszSrc è un puntatore Null e, in caso affermativo, generano un E_INVALIDARG errore.
La versione con un solo parametro di SetString prevede pszSrc di puntare a una stringa con terminazione Null.
Anche la versione a due parametri di SetString prevede pszSrc che sia una stringa con terminazione Null. Viene usato nLength come lunghezza della stringa, a meno che non si verifichi prima un carattere di terminazione Null.
La versione a due parametri di SetString controlla anche se pszSrc punta a una posizione nel buffer corrente in CSimpleStringT. In questo caso speciale, SetString usa una funzione di copia della memoria che non sovrascrive i dati stringa mentre copia i dati stringa nel relativo buffer.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::SetString.
CSimpleString s(_T("abcdef"), pMgr);
ASSERT(_tcscmp(s, _T("abcdef")) == 0);
s.SetString(_T("Soccer"), 6);
ASSERT(_tcscmp(s, _T("Soccer")) == 0);
CSimpleStringT::StringLength
Restituisce il numero di caratteri nella stringa specificata.
Sintassi
ATL_NOINLINE static int StringLength(PCXSTR psz) throw();
Parametri
psz
Puntatore a una stringa con terminazione Null.
Valore restituito
Numero di caratteri in psz, senza contare un carattere di terminazione Null.
Osservazioni:
Chiamare questo metodo per recuperare il numero di caratteri nella stringa a pszcui punta .
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::StringLength.
ASSERT(CSimpleString::StringLength(_T("soccer")) == 6);
CSimpleStringT::Truncate
Tronca la stringa alla nuova lunghezza.
Sintassi
void Truncate(int nNewLength);
Parametri
nNewLength
Nuova lunghezza della stringa.
Osservazioni:
Chiamare questo metodo per troncare il contenuto della stringa alla nuova lunghezza.
Nota
Ciò non influisce sulla lunghezza allocata del buffer. Per ridurre o aumentare il buffer corrente, vedere FreeExtra e Preallocate.
Esempio
L'esempio seguente illustra l'uso di CSimpleStringT::Truncate.
CAtlString basestr;
IAtlStringMgr* pMgr = basestr.GetManager();
CSimpleString str(_T("abcdefghi"), pMgr);
_tprintf_s(_T("String length: %d / Allocated length: %d\n"), str.GetLength(), str.GetAllocLength());
_tprintf_s(_T("Contents: %s\n"), (LPCTSTR)str);
str.Truncate(4);
_tprintf_s(_T("String length: %d / Allocated length: %d\n"), str.GetLength(), str.GetAllocLength());
_tprintf_s(_T("Contents: %s\n"), (LPCTSTR)str);
L'output di questo esempio è:
String length: 9 / Allocated length: 15
Contents: abcdefghi
String length: 4 / Allocated length: 15
Contents: abcd
CSimpleStringT::UnlockBuffer
Sblocca il buffer dell'oggetto CSimpleStringT .
Sintassi
void UnlockBuffer() throw();
Osservazioni:
Chiamare questo metodo per reimpostare il numero di riferimenti della stringa su 1.
Il CSimpleStringT distruttore chiama UnlockBuffer automaticamente per assicurarsi che il buffer non sia bloccato quando viene chiamato il distruttore. Per un esempio di questo metodo, vedere LockBuffer.
CSimpleStringT::~CSimpleStringT
Elimina un oggetto CSimpleStringT .
Sintassi
~CSimpleStringT() throw();
Osservazioni:
Chiamare questo metodo per eliminare definitivamente l'oggetto CSimpleStringT .
Vedi anche
Commenti e suggerimenti
Presto disponibile: Nel corso del 2024 verranno gradualmente disattivati i problemi di GitHub come meccanismo di feedback per il contenuto e ciò verrà sostituito con un nuovo sistema di feedback. Per altre informazioni, vedere https://aka.ms/ContentUserFeedback.
Invia e visualizza il feedback per