Condividi tramite


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

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:

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

Grafico della gerarchia
Classi condivise ATL/MFC