Classe `CSimpleStringT`

Articolo
01/26/2024

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 `CSimpleStringT`oggetto , 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 typedef CSimpleString. 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:

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

Nota

`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

Grafico della gerarchia
Classi condivise ATL/MFC

Condividi tramite

Classe CSimpleStringT

Sintassi

Parametri

Membri

Typedef pubblici

Costruttori pubblici

Metodi pubblici

Operatori pubblici

Osservazioni:

Requisiti

CSimpleStringT::Append

Sintassi

Parametri

Osservazioni:

Esempio

CSimpleStringT::AppendChar

Sintassi

Parametri

Osservazioni:

CSimpleStringT::CopyChars

Sintassi

Parametri

Osservazioni:

Esempio

CSimpleStringT::CopyCharsOverlapped

Sintassi

Parametri

Osservazioni:

Esempio

CSimpleStringT::CSimpleStringT

Sintassi

Parametri

Osservazioni:

Esempio

CSimpleStringT::Empty

Sintassi

Osservazioni:

Esempio

CSimpleStringT::FreeExtra

Sintassi

Osservazioni:

Esempio

CSimpleStringT::GetAllocLength

Sintassi

Valore restituito

Osservazioni:

CSimpleStringT::GetAt

Sintassi

Parametri

Valore restituito

Osservazioni:

Esempio

CSimpleStringT::GetBuffer

Sintassi

Parametri

Valore restituito

Osservazioni:

Esempio

CSimpleStringT::GetBufferSetLength

Sintassi

Parametri

Valore restituito

Osservazioni:

Esempio

CSimpleStringT::GetLength

Sintassi

Valore restituito

Osservazioni:

CSimpleStringT::GetManager

Sintassi

Valore restituito

Osservazioni:

CSimpleStringT::GetString

Sintassi

Valore restituito

Osservazioni:

Esempio

CSimpleStringT::IsEmpty

Sintassi

Classe `CSimpleStringT`

`CSimpleStringT::Append`

`CSimpleStringT::AppendChar`

`CSimpleStringT::CopyChars`

`CSimpleStringT::CopyCharsOverlapped`

`CSimpleStringT::CSimpleStringT`

`CSimpleStringT::Empty`

`CSimpleStringT::FreeExtra`

`CSimpleStringT::GetAllocLength`

`CSimpleStringT::GetAt`

`CSimpleStringT::GetBuffer`

`CSimpleStringT::GetBufferSetLength`

`CSimpleStringT::GetLength`

`CSimpleStringT::GetManager`

`CSimpleStringT::GetString`

`CSimpleStringT::IsEmpty`

`CSimpleStringT::LockBuffer`

`CSimpleStringT::operator[]`

`CSimpleStringT::operator []`

`CSimpleStringT::operator +=`

`CSimpleStringT::operator =`

`CSimpleStringT::operator PCXSTR`

`CSimpleStringT::PCXSTR`

`CSimpleStringT::Preallocate`

`CSimpleStringT::PXSTR`

`CSimpleStringT::ReleaseBuffer`

`CSimpleStringT::ReleaseBufferSetLength`

`CSimpleStringT::SetAt`

`CSimpleStringT::SetManager`

`CSimpleStringT::SetString`

`CSimpleStringT::StringLength`