Share via

La classe CStringT

  • Article

Cette classe représente un CStringT objet.

Syntaxe

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

Paramètres

BaseType
Type de caractère de la classe de chaîne. Il peut s'agir d'une des méthodes suivantes :

  • char (pour les chaînes de caractères ANSI).

  • wchar_t (pour les chaînes de caractères Unicode).

  • TCHAR (pour les chaînes de caractères ANSI et Unicode).

StringTraits
Détermine si la classe de chaîne a besoin de la prise en charge de la bibliothèque CRT (C Run-Time) et de l’emplacement des ressources de chaîne. Il peut s'agir d'une des méthodes suivantes :

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

    La classe nécessite la prise en charge CRT et recherche des chaînes de ressources dans le module spécifié par m_hInstResource (membre de la classe de module de l’application).

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

    La classe ne nécessite pas de prise en charge CRT et recherche des chaînes de ressources dans le module spécifié par m_hInstResource (membre de la classe de module de l’application).

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

    La classe nécessite la prise en charge crt et recherche des chaînes de ressources à l’aide de l’algorithme de recherche MFC standard.

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

    La classe ne nécessite pas de prise en charge CRT et recherche des chaînes de ressources à l’aide de l’algorithme de recherche MFC standard.

Membres

Constructeurs publics

Nom Description
CStringT::CStringT Construit un CStringT objet de différentes façons.
CStringT::~CStringT Détruit un objet CStringT .

Méthodes publiques

Nom Description
CStringT::AllocSysString Alloue une BSTR donnée à partir de CStringT données.
CStringT::AnsiToOem Effectue une conversion sur place du jeu de caractères ANSI vers le jeu de caractères OEM.
CStringT::AppendFormat Ajoute des données mises en forme à un objet existant CStringT .
CStringT::Collate Compare deux chaînes (respectant la casse, utilise des informations spécifiques aux paramètres régionaux).
CStringT::CollateNoCase Compare deux chaînes (sans respect de la casse, utilise des informations spécifiques aux paramètres régionaux).
CStringT::Compare Compare deux chaînes (respectant la casse).
CStringT::CompareNoCase Compare deux chaînes (sans respect de la casse).
CStringT::Delete Supprime un caractère ou des caractères d’une chaîne.
CStringT::Find Recherche un caractère ou une sous-chaîne à l’intérieur d’une chaîne plus grande.
CStringT::FindOneOf Recherche le premier caractère correspondant d’un jeu.
CStringT::Format Met en forme la chaîne comme sprintf c’est le cas.
CStringT::FormatMessage Met en forme une chaîne de message.
CStringT::FormatMessageV Met en forme une chaîne de message à l’aide d’une liste d’arguments de variable.
CStringT::FormatV Met en forme la chaîne à l’aide d’une liste variable d’arguments.
CStringT::GetEnvironmentVariable Définit la chaîne sur la valeur de la variable d’environnement spécifiée.
CStringT::Insert Insère un caractère unique ou une sous-chaîne à l’index donné dans la chaîne.
CStringT::Left Extrait la partie gauche d’une chaîne.
CStringT::LoadString Charge un objet existant CStringT à partir d’une ressource Windows.
CStringT::MakeLower Convertit tous les caractères de cette chaîne en caractères minuscules.
CStringT::MakeReverse Inverse la chaîne.
CStringT::MakeUpper Convertit tous les caractères de cette chaîne en caractères majuscules.
CStringT::Mid Extrait la partie centrale d’une chaîne.
CStringT::OemToAnsi Effectue une conversion sur place du jeu de caractères OEM vers le jeu de caractères ANSI.
CStringT::Remove Supprime les caractères indiqués d’une chaîne.
CStringT::Replace Remplace les caractères indiqués par d’autres caractères.
CStringT::ReverseFind Recherche un caractère à l’intérieur d’une chaîne plus grande ; commence à partir de la fin.
CStringT::Right Extrait la partie droite d’une chaîne.
CStringT::SetSysString Définit un objet existant BSTR avec des données d’un CStringT objet.
CStringT::SpanExcluding Extrait les caractères de la chaîne, en commençant par le premier caractère, qui ne figurent pas dans l’ensemble de caractères identifiés par pszCharSet.
CStringT::SpanIncluding Extrait une sous-chaîne qui contient uniquement les caractères d’un jeu.
CStringT::Tokenize Extrait les jetons spécifiés dans une chaîne cible.
CStringT::Trim Supprime tous les espaces blancs de début et de fin de la chaîne.
CStringT::TrimLeft Supprime les espaces blancs de début de la chaîne.
CStringT::TrimRight Supprime les espaces blancs de fin de la chaîne.

Opérateurs

Nom Description
CStringT::operator = Affecte une nouvelle valeur à un CStringT objet.
CStringT::operator + Concatène deux chaînes, ou un caractère et une chaîne.
CStringT::operator += Concatène une nouvelle chaîne à la fin d’une chaîne existante.
CStringT::operator == Détermine si deux chaînes sont logiquement égales.
CStringT::operator != Détermine si deux chaînes ne sont pas logiquement égales.
CStringT::operator < Détermine si la chaîne sur le côté gauche de l’opérateur est inférieure à la chaîne du côté droit.
CStringT::operator > Détermine si la chaîne sur le côté gauche de l’opérateur est supérieure à la chaîne du côté droit.
CStringT::operator <= Détermine si la chaîne sur le côté gauche de l’opérateur est inférieure ou égale à la chaîne à droite.
CStringT::operator >= Détermine si la chaîne sur le côté gauche de l’opérateur est supérieure ou égale à la chaîne sur le côté droit.

Notes

CStringT hérite de CSimpleStringT la classe. Les fonctionnalités avancées, telles que la manipulation de caractères, l’ordre et la recherche, sont implémentées par CStringT.

Remarque

CStringT les objets sont capables de lever des exceptions. Cela se produit lorsqu’un CStringT objet manque de mémoire pour une raison quelconque.

Un CStringT objet se compose d’une séquence de caractères de longueur variable. CStringT fournit des fonctions et des opérateurs utilisant une syntaxe similaire à celle de Basic. Les opérateurs de concaténation et de comparaison, ainsi que la gestion simplifiée de la mémoire, facilitent CStringT l’utilisation des objets que les tableaux de caractères ordinaires.

Remarque

Bien qu’il soit possible de créer CStringT des instances qui contiennent des caractères null incorporés, nous vous recommandons de le faire. L’appel de méthodes et d’opérateurs sur CStringT des objets qui contiennent des caractères null incorporés peut produire des résultats inattendus.

En utilisant différentes combinaisons des paramètres et StringTraits des BaseType objets, CStringT les objets peuvent se trouver dans les types suivants, qui ont été prédéfinis par les bibliothèques ATL.

Si vous utilisez dans une application ATL :

CString, CStringAet CStringW sont exportés à partir de la DLL MFC (MFC90.DLL), jamais à partir de DLL utilisateur. Cela permet d’éviter CStringT d’être défini plusieurs fois.

Remarque

Si votre code contient la solution de contournement pour les erreurs de l’éditeur de liens décrites dans l’exportation de classes de chaîne à l’aide de CStringT, vous devez supprimer ce code. Ce n'est plus nécessaire.

Les types de chaînes suivants sont disponibles dans les applications MFC :

Type CStringT Déclaration
CStringA Chaîne de type caractère ANSI avec prise en charge CRT.
CStringW Chaîne de type caractère Unicode avec prise en charge CRT.
CString Types de caractères ANSI et Unicode avec prise en charge CRT.

Les types de chaînes suivants sont disponibles dans les projets où ATL_CSTRING_NO_CRT est défini :

Type CStringT Déclaration
CAtlStringA Chaîne de type caractère ANSI sans prise en charge CRT.
CAtlStringW Chaîne de type caractère Unicode sans prise en charge CRT.
CAtlString Types de caractères ANSI et Unicode sans prise en charge CRT.

Les types de chaînes suivants sont disponibles dans les projets où ATL_CSTRING_NO_CRT il n’est pas défini :

Type CStringT Déclaration
CAtlStringA Chaîne de type caractère ANSI avec prise en charge CRT.
CAtlStringW Chaîne de type caractère Unicode avec prise en charge CRT.
CAtlString Types de caractères ANSI et Unicode avec prise en charge CRT.

CString les objets ont également les caractéristiques suivantes :

  • CStringT les objets peuvent croître en raison d’opérations de concaténation.

  • CStringT les objets suivent la « sémantique des valeurs ». Considérez un CStringT objet comme une chaîne réelle, et non comme un pointeur vers une chaîne.

  • Vous pouvez remplacer CStringT librement des objets pour PCXSTR les arguments de fonction.

  • Gestion de la mémoire personnalisée pour les mémoires tampons de chaîne. Pour plus d’informations, consultez Gestion de la mémoire et CStringT.

Types prédéfinis CStringT

Étant donné que CStringT l’utilisation d’un argument de modèle pour définir le type de caractère (ou wchar_tchar) pris en charge, les types de paramètres de méthode peuvent être compliqués à la fois. Pour simplifier ce problème, un ensemble de types prédéfinis est défini et utilisé dans toute la CStringT classe. Le tableau suivant répertorie les différents types :

Nom Description
XCHAR Caractère unique (ou wchar_tchar) avec le même type de caractère que l’objet CStringT .
YCHAR Caractère unique (ou wchar_tchar) avec le type de caractère opposé en tant qu’objet CStringT .
PXSTR Pointeur vers une chaîne de caractères (ou wchar_tchar) avec le même type de caractère que l’objet CStringT .
PYSTR Pointeur vers une chaîne de caractères (ou wchar_tchar) avec le type de caractère opposé en tant qu’objet CStringT .
PCXSTR Pointeur vers une const chaîne de caractères (ou charwchar_t ) avec le même type de caractère que l’objetCStringT.
PCYSTR Pointeur vers une const chaîne de caractères (ou charwchar_t ) avec le type de caractère opposé en tant qu’objetCStringT.

Remarque

Le code qui utilisait précédemment des méthodes non documentées de CString (par exemple AssignCopy) doit être remplacé par du code qui utilise les méthodes documentées suivantes ( CStringT telles que GetBuffer ou ReleaseBuffer). Ces méthodes sont héritées de CSimpleStringT.

Hiérarchie d'héritage

CSimpleStringT

CStringT

Spécifications

En-tête Utilisée pour
cstringt.h Objets de chaîne MFC uniquement
atlstr.h Objets de chaîne non MFC

CStringT::AllocSysString

Alloue une chaîne compatible Automation du type BSTR et copie le contenu de l’objet CStringT dans celui-ci, y compris le caractère null de fin.

BSTR AllocSysString() const;

Valeur de retour

Chaîne nouvellement allouée.

Notes

Dans les programmes MFC, une CMemoryException classe est levée si la mémoire est insuffisante. Dans les programmes ATL, a CAtlException été levée. Cette fonction est normalement utilisée pour retourner des chaînes pour Automation.

Généralement, si cette chaîne est passée à une fonction COM en tant que [in] paramètre, l’appelant doit libérer la chaîne. Pour ce faire SysFreeString, procédez comme décrit dans le Kit de développement logiciel (SDK) Windows. Pour plus d’informations, consultez Allocation et libération de la mémoire pour un BSTR.

Pour plus d’informations sur les fonctions d’allocation OLE dans Windows, consultez SysAllocString le Kit de développement logiciel (SDK) Windows.

Exemple

L'exemple suivant montre l'utilisation de CStringT::AllocSysString.

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

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

CStringT::AnsiToOem

Convertit tous les caractères de cet CStringT objet du jeu de caractères ANSI en jeu de caractères OEM.

void AnsiToOem();

Notes

La fonction n’est pas disponible si _UNICODE elle est définie.

Exemple

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

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

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

CStringT::AppendFormat

Ajoute des données mises en forme à un objet existant CStringT .

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

Paramètres

pszFormat
Chaîne de contrôle de format.

nFormatID
Identificateur de ressource de chaîne qui contient la chaîne de contrôle de format.

argument
Arguments facultatifs.

Notes

Cette fonction met en forme et ajoute une série de caractères et de valeurs dans le CStringT. Chaque argument facultatif (le cas échéant) est converti et ajouté conformément à la spécification de format correspondante dans pszFormat ou à partir de la ressource de chaîne identifiée par nFormatID.

Exemple

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

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

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

CStringT::Collate

Compare deux chaînes à l’aide de la fonction _tcscollde texte générique .

int Collate(PCXSTR psz) const throw();

Paramètres

psz
Autre chaîne utilisée pour la comparaison.

Valeur de retour

Zéro si les chaînes sont identiques, < 0 si cet CStringT objet est inférieur pszà , ou > 0 si cet CStringT objet est supérieur pszà .

Notes

La fonction _tcscollde texte générique , définie dans TCHAR.H, est mappée à l’un strcollwcscollou l’autre , ou _mbscoll, selon le jeu de caractères défini au moment de la compilation. Chaque fonction effectue une comparaison sensible à la casse des chaînes en fonction de la page de codes actuellement utilisée. Pour plus d’informations, consultez strcoll, , _mbscoll_strcoll_lwcscoll, , _wcscoll_l_mbscoll_l.

CStringT::CollateNoCase

Compare deux chaînes à l’aide de la fonction _tcscollde texte générique .

int CollateNoCase(PCXSTR psz) const throw();

Paramètres

psz
Autre chaîne utilisée pour la comparaison.

Valeur de retour

Zéro si les chaînes sont identiques (en ignorant la casse), < 0 si cet CStringT objet est inférieur psz à (en ignorant la casse) ou > 0 si cet CStringT objet est supérieur psz à (en ignorant le cas).

Notes

La fonction _tcscollde texte générique , définie dans TCHAR.H, est mappée à l’un stricollwcsicollou l’autre , ou _mbsicoll, selon le jeu de caractères défini au moment de la compilation. Chaque fonction effectue une comparaison qui ne respecte pas la casse des chaînes, selon la page de codes actuellement utilisée. Pour plus d’informations, consultez strcoll, , _mbscollwcscoll_strcoll_l, , . _mbscoll_l_wcscoll_l

Exemple

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

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

int n;

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

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

CStringT::Compare

Compare deux chaînes (respectant la casse).

int Compare(PCXSTR psz) const;

Paramètres

psz
Autre chaîne utilisée pour la comparaison.

Valeur de retour

Zéro si les chaînes sont identiques, < 0 si cet CStringT objet est inférieur pszà , ou > 0 si cet CStringT objet est supérieur pszà .

Notes

La fonction _tcscmpde texte générique , définie dans TCHAR.H, est mappée à l’un strcmpwcscmpou l’autre , ou _mbscmp, selon le jeu de caractères défini au moment de la compilation. Chaque fonction effectue une comparaison sensible à la casse des chaînes et n’est pas affectée par les paramètres régionaux. Pour plus d’informations, consultez strcmp, . _mbscmpwcscmp

Si la chaîne contient des valeurs Null incorporées, à des fins de comparaison, la chaîne est considérée comme tronquée au premier caractère null incorporé.

Exemple

L'exemple suivant montre l'utilisation de CStringT::Compare.

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

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

CStringT::CompareNoCase

Compare deux chaînes (sans respect de la casse).

int CompareNoCase(PCXSTR psz) const throw();

Paramètres

psz
Autre chaîne utilisée pour la comparaison.

Valeur de retour

Zéro si les chaînes sont identiques (en ignorant la casse), <0 si cet CStringT objet est inférieur psz à (en ignorant la casse) ou >0 si cet CStringT objet est supérieur psz à (en ignorant le cas).

Notes

La fonction _tcsicmpde texte générique, définie dans TCHAR.H, est mappée à l’un _stricmp_wcsicmp ou _mbsicmpl’autre, selon le jeu de caractères défini au moment de la compilation. Chaque fonction effectue une comparaison sans respect de la casse des chaînes. La comparaison dépend de l’aspect LC_CTYPE des paramètres régionaux, mais pas LC_COLLATE. Pour plus d’informations, consultez _stricmp, , _mbsicmp_wcsicmp_stricmp_l, , . _mbsicmp_l_wcsicmp_l

Exemple

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

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

CStringT::CStringT

Construit un objet CStringT.

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

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

CStringT(const VARIANT& varSrc);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Paramètres

pch
Pointeur vers un tableau de caractères de longueur nLength, et non terminé par null.

nLength
Nombre de caractères dans pch.

ch
Caractère unique.

pszSrc
Chaîne terminée par null à copier dans cet CStringT objet.

pStringMgr
Pointeur vers le gestionnaire de mémoire de l’objet CStringT . Pour plus d’informations sur IAtlStringMgr la gestion de la mémoire, CStringTconsultez Gestion de la mémoire avec CStringT.

strSrc
Objet existant CStringT à copier dans cet CStringT objet. Pour plus d’informations sur et CThisSimpleStringpour plus d’informationsCThisString, consultez la section Remarques.

varSrc
Objet variant à copier dans cet CStringT objet.

BaseType
Type de caractère de la classe de chaîne. Il peut s'agir d'une des méthodes suivantes :

char (pour les chaînes de caractères ANSI).

wchar_t (pour les chaînes de caractères Unicode).

TCHAR (pour les chaînes de caractères ANSI et Unicode).

bMFCDLL
Boolean qui spécifie si le projet est une DLL MFC () ouTRUE non (FALSE).

SystemString
Doit être System::String, et le projet doit être compilé avec /clr.

pString
Handle pour un CStringT objet.

Notes

Étant donné que les constructeurs copient les données d’entrée dans un nouveau stockage alloué, des exceptions de mémoire peuvent se produire. Certains de ces constructeurs agissent en tant que fonctions de conversion. Cela vous permet de remplacer, par exemple, un LPTSTR objet dans lequel un CStringT objet est attendu.

  • CStringT( LPCSTRlpsz ) : construit un Unicode CStringT à partir d’une chaîne ANSI. Vous pouvez également utiliser ce constructeur pour charger une ressource de chaîne, comme illustré dans l’exemple ci-dessous.

  • CStringT(LPCWSTRlpsz : construit à CStringT partir d’une chaîne Unicode.

  • CStringT( const unsigned char*psz ) : vous permet de construire un CStringT pointeur vers unsigned char.

Remarque

Définissez la macro pour désactiver la _CSTRING_DISABLE_NARROW_WIDE_CONVERSION conversion implicite de chaînes entre les chaînes ANSI et Unicode. La macro exclut des constructeurs de compilation qui prennent en charge la conversion.

Le strSrc paramètre peut être un ou CThisSimpleString un CStringT objet. Pour CStringT, utilisez l’une de ses instanciations par défaut (CString, CStringAou CStringW) ; pour , utilisez CThisSimpleStringun this pointeur. CThisSimpleString déclare une instance de la CSimpleStringT classe, qui est une classe de chaîne plus petite avec moins de fonctionnalités intégrées que la CStringT classe.

L’opérateur CSimpleStringT<>&() de surcharge construit un CStringT objet à partir d’une CSimpleStringT déclaration.

Remarque

Bien qu’il soit possible de créer CStringT des instances qui contiennent des caractères null incorporés, nous vous recommandons de le faire. L’appel de méthodes et d’opérateurs sur CStringT des objets qui contiennent des caractères null incorporés peut produire des résultats inattendus.

Exemple

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

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

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

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

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

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

CStringT::~CStringT

Détruit l’objet CStringT .

~CStringT() throw();

Notes

Détruit l’objet CStringT .

CStringT::Delete

Supprime un caractère ou des caractères d’une chaîne commençant par le caractère à l’index donné.

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

Paramètres

iIndex
Index de base zéro du premier caractère de l’objet CStringT à supprimer.

nCount
Nombre de caractères à supprimer.

Valeur de retour

Longueur de la chaîne modifiée.

Notes

Si nCount elle est plus longue que la chaîne, le reste de la chaîne est supprimé.

Exemple

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

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

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

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

CStringT::Find

Recherche cette chaîne pour la première correspondance d’un caractère ou d’une sous-chaîne.

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

Paramètres

pszSub
Sous-chaîne à rechercher.

iStart
Index du caractère dans la chaîne avec lequel commencer la recherche, ou 0 pour commencer à partir du début.

ch
Caractère unique à rechercher.

Valeur de retour

Index de base zéro du premier caractère de cet CStringT objet qui correspond à la sous-chaîne ou aux caractères demandés ; -1 si la sous-chaîne ou le caractère n’est pas trouvé.

Notes

La fonction est surchargée pour accepter à la fois des caractères uniques (similaires à la fonction strchrd’exécution) et des chaînes (similaires à strstr).

Exemple

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

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

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

CStringT::FindOneOf

Recherche cette chaîne pour le premier caractère qui correspond à n’importe quel caractère contenu dans pszCharSet.

int FindOneOf(PCXSTR pszCharSet) const throw();

Paramètres

pszCharSet
Chaîne contenant des caractères correspondants.

Valeur de retour

Index de base zéro du premier caractère de cette chaîne qui est également dans pszCharSet; -1 s’il n’y a pas de correspondance.

Notes

Recherche la première occurrence de l’un des caractères dans pszCharSet.

Exemple

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

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

CStringT::Format

Écrit des données mises en forme dans une CStringT même façon que les sprintf_s données dans un tableau de caractères de style C.

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

Paramètres

nFormatID
Identificateur de ressource de chaîne qui contient la chaîne de contrôle de format.

pszFormat
Chaîne de contrôle de format.

argument
Arguments facultatifs.

Notes

Cette fonction met en forme et stocke une série de caractères et de valeurs dans le CStringT. Chaque argument facultatif (le cas échéant) est converti et généré en fonction de la spécification de format correspondante dans pszFormat ou à partir de la ressource de chaîne identifiée par nFormatID.

L’appel échoue si l’objet de chaîne lui-même est proposé en tant que paramètre à Format. Par exemple, le code suivant entraîne des résultats imprévisibles :

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

Pour plus d’informations, consultez Syntaxe de spécification de format : printf et wprintf Fonctions.

Exemple

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

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

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

CStringT::FormatMessage

Met en forme une chaîne de message.

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

Paramètres

nFormatID
Identificateur de ressource de chaîne qui contient le texte du message non mis en forme.

pszFormat
Pointe vers la chaîne de contrôle de format. Il sera analysé pour les insertions et mis en forme en conséquence. La chaîne de format est similaire aux chaînes de format de style de fonction printfd’exécution, sauf qu’elle permet d’insérer les paramètres dans un ordre arbitraire.

argument
Arguments facultatifs.

Notes

La fonction nécessite une définition de message en tant qu’entrée. La définition du message est déterminée par ou à pszFormat partir de la ressource de chaîne identifiée par nFormatID. La fonction copie le texte du message mis en forme dans l’objet CStringT , en traitant les séquences d’insertion incorporées si demandées.

Remarque

FormatMessage tente d’allouer la mémoire système pour la chaîne nouvellement mise en forme. Si cette tentative échoue, une exception de mémoire est levée automatiquement.

Chaque insertion doit avoir un paramètre correspondant suivant le ou nFormatID le pszFormat paramètre. Dans le texte du message, plusieurs séquences d’échappement sont prises en charge pour la mise en forme dynamique du message. Pour plus d’informations, consultez la fonction Windows FormatMessage dans le Kit de développement logiciel (SDK) Windows.

Exemple

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

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

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

CStringT::FormatMessageV

Met en forme une chaîne de message à l’aide d’une liste d’arguments de variable.

void FormatMessageV(PCXSTR pszFormat, va_list* pArgList);

Paramètres

pszFormat
Pointe vers la chaîne de contrôle de format. Il sera analysé pour les insertions et mis en forme en conséquence. La chaîne de format est similaire aux chaînes de format de style de fonction printfd’exécution, sauf qu’elle permet d’insérer les paramètres dans un ordre arbitraire.

pArgList
Pointeur vers une liste d’arguments.

Notes

La fonction nécessite une définition de message comme entrée, déterminée par pszFormat. La fonction copie le texte du message mis en forme et une liste variable d’arguments dans l’objet CStringT , en traitant les séquences d’insertion incorporées si nécessaire.

Remarque

FormatMessageV appelle CStringT::FormatMessage, qui tente d’allouer la mémoire système pour la chaîne nouvellement mise en forme. Si cette tentative échoue, une exception de mémoire est levée automatiquement.

Pour plus d’informations, consultez la fonction Windows FormatMessage dans le Kit de développement logiciel (SDK) Windows.

CStringT::FormatV

Met en forme une chaîne de message à l’aide d’une liste d’arguments de variable.

void FormatV(PCXSTR pszFormat, va_list args);

Paramètres

pszFormat
Pointe vers la chaîne de contrôle de format. Il sera analysé pour les insertions et mis en forme en conséquence. La chaîne de format est similaire aux chaînes de format de style de fonction printfd’exécution, sauf qu’elle permet d’insérer les paramètres dans un ordre arbitraire.

args
Pointeur vers une liste d’arguments.

Notes

Écrit une chaîne mise en forme et une liste variable d’arguments dans une CStringT chaîne de la même façon que celle qui vsprintf_s met en forme les données dans un tableau de caractères de style C.

Exemple

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

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

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

    _tprintf_s(str);
    return;
}

 

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

CStringT::GetEnvironmentVariable

Définit la chaîne sur la valeur de la variable d’environnement spécifiée.

BOOL GetEnvironmentVariable(PCXSTR pszVar);

Paramètres

pszVar
Pointeur vers une chaîne terminée par null qui spécifie la variable d’environnement.

Valeur de retour

Valeur différente de zéro cas de réussite ; sinon, 0.

Notes

Récupère la valeur de la variable spécifiée à partir du bloc d’environnement du processus appelant. La valeur se présente sous la forme d’une chaîne de caractères terminée par null.

Exemple

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

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

CStringT::Insert

Insère un caractère unique ou une sous-chaîne à l’index donné dans la chaîne.

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

Paramètres

iIndex
Index du caractère avant lequel l’insertion aura lieu.

psz
Pointeur vers la sous-chaîne à insérer.

ch
Caractère à insérer.

Valeur de retour

Longueur de la chaîne modifiée.

Notes

Le iIndex paramètre identifie le premier caractère qui sera déplacé pour rendre la place du caractère ou de la sous-chaîne. Si nIndex elle est égale à zéro, l’insertion se produit avant la chaîne entière. Si nIndex est supérieur à la longueur de la chaîne, la fonction concatène la chaîne actuelle et le nouveau matériau fourni par l’une ou l’autre chpsz.

Exemple

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

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

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

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

CStringT::Left

Extrait les caractères les plus nCount à gauche de cet CStringT objet et retourne une copie de la sous-chaîne extraite.

CStringT Left(int nCount) const;

Paramètres

nCount
Nombre de caractères à extraire de cet objet CStringT.

Valeur de retour

Objet CStringT qui contient une copie de la plage spécifiée des caractères. L'objet retourné par CStringT peut être vide.

Notes

Si nCount elle dépasse la longueur de la chaîne, la chaîne entière est extraite. Left est similaire à la fonction de base Left.

Pour les jeux de caractères multioctets (Mo CS), nCount traite chaque séquence 8 bits en tant que caractère, afin de renvoyer nCount le nombre de caractères multioctets multiplié par deux.

Exemple

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

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

CStringT::LoadString

Lit une ressource de chaîne Windows, identifiée par nID, dans un objet existant CStringT .

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

Paramètres

hInstance
Handle de l’instance du module.

nID
ID de ressource de chaîne Windows.

wLanguageID
Langue de la ressource de chaîne.

Valeur de retour

Différent de zéro si la charge des ressources a réussi ; sinon 0.

Notes

Charge la ressource de chaîne (nID) à partir du module spécifié (hInstance) à l’aide de la langue spécifiée (wLanguage).

Exemple

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

CAtlString s;
s.LoadString(IDS_APP_TITLE);

CStringT::MakeLower

Convertit l’objet CStringT en chaîne minuscule.

CStringT& MakeLower();

Valeur de retour

Chaîne minuscule résultante.

Exemple

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

CAtlString s(_T("ABC"));

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

CStringT::MakeReverse

Inverse l’ordre des caractères dans l’objet CStringT .

CStringT& MakeReverse();

Valeur de retour

Chaîne inversée résultante.

Exemple

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

CAtlString s(_T("abc"));

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

CStringT::MakeUpper

Convertit l’objet CStringT en chaîne majuscule.

CStringT& MakeUpper();

Valeur de retour

Chaîne majuscule résultante.

Notes

Exemple

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

CAtlString s(_T("abc"));

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

CStringT::Mid

Extrait une sous-chaîne de caractères de longueur nCount de cet CStringT objet, en commençant à la position iFirst (de base zéro).

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

Paramètres

iFirst
Index de base zéro du premier caractère de cet CStringT objet à inclure dans la sous-chaîne extraite.

nCount
Nombre de caractères à extraire de cet objet CStringT. Si ce paramètre n’est pas fourni, le reste de la chaîne est extrait.

Valeur de retour

Objet CStringT qui contient une copie de la plage spécifiée des caractères. L'objet retourné par CStringT peut être vide.

Notes

La fonction retourne une copie de la sous-chaîne extraite. Mid est similaire à la fonction De base Mid (sauf que les index de Basic sont basés sur un seul).

Pour les jeux de caractères multioctets (Mo CS), nCount fait référence à chaque caractère 8 bits ; autrement dit, un octet de début et de fin dans un caractère multioctet est compté sous la forme de deux caractères.

Exemple

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

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

CStringT::OemToAnsi

Convertit tous les caractères de cet CStringT objet du jeu de caractères OEM en jeu de caractères ANSI.

void OemToAnsi();

Notes

Cette fonction n’est pas disponible si _UNICODE elle est définie.

Exemple

Consultez l’exemple pour CStringT::AnsiToOem.

CStringT::operator =

Affecte une nouvelle valeur à la chaîne.

CStringT& operator=(const CStringT& strSrc);

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

Paramètres

strSrc
A CStringT à affecter à cette chaîne.

str
Référence à un objet CThisSimpleString.

bMFCDLL
Valeur booléenne spécifiant si le projet est une DLL MFC ou non.

BaseType
Type de base de chaîne.

var
Objet variant à affecter à cette chaîne.

ch
Caractère ANSI ou Unicode à affecter à la chaîne.

pszSrc
Pointeur vers la chaîne d’origine affectée.

Notes

L’opérateur d’affectation accepte un autre CStringT objet, un pointeur de caractère ou un seul caractère. Des exceptions de mémoire peuvent se produire chaque fois que vous utilisez cet opérateur, car le nouveau stockage peut être alloué.

Pour plus d’informations sur CThisSimpleString, consultez la section Remarques de CStringT::CStringT.

Remarque

Bien qu’il soit possible de créer CStringT des instances qui contiennent des caractères null incorporés, nous vous recommandons de le faire. L’appel de méthodes et d’opérateurs sur CStringT des objets qui contiennent des caractères null incorporés peut produire des résultats inattendus.

CStringT::operator +

Concatène deux chaînes ou un caractère et une chaîne.

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

Paramètres

ch1
Caractère ANSI ou Unicode à concaténer avec une chaîne.

ch2
Caractère ANSI ou Unicode à concaténer avec une chaîne.

str1
À CStringT concaténer avec une chaîne ou un caractère.

str2
À CStringT concaténer avec une chaîne ou un caractère.

psz1
Pointeur vers une chaîne terminée par null pour concaténer avec une chaîne ou un caractère.

psz2
Pointeur vers une chaîne à concaténer avec une chaîne ou un caractère.

Notes

Il existe sept formes de surcharge de la CStringT::operator+ fonction. La première version concatène deux objets existants CStringT . Les deux suivantes concatènent un CStringT objet et une chaîne terminée par null. Les deux suivantes concatènent un CStringT objet et un caractère ANSI. Les deux derniers concatènent un CStringT objet et un caractère Unicode.

Remarque

Bien qu’il soit possible de créer CStringT des instances qui contiennent des caractères null incorporés, nous vous recommandons de le faire. L’appel de méthodes et d’opérateurs sur CStringT des objets qui contiennent des caractères null incorporés peut produire des résultats inattendus.

Exemple

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

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

CStringT::operator +=

Concatène les caractères à la fin de la chaîne.

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

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

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

Paramètres

str
Référence à un objet CThisSimpleString.

bMFCDLL
Valeur booléenne spécifiant si le projet est une DLL MFC ou non.

BaseType
Type de base de chaîne.

var
Objet variant à concaténer à cette chaîne.

ch
Caractère ANSI ou Unicode à concaténer avec une chaîne.

pszSrc
Pointeur vers la chaîne d’origine concaténée.

strSrc
À CStringT concaténer à cette chaîne.

Notes

L’opérateur accepte un autre CStringT objet, un pointeur de caractère ou un seul caractère. Les exceptions de mémoire peuvent se produire chaque fois que vous utilisez cet opérateur de concaténation, car le nouveau stockage peut être alloué pour les caractères ajoutés à cet CStringT objet.

Pour plus d’informations sur CThisSimpleString, consultez la section Remarques de CStringT::CStringT.

Remarque

Bien qu’il soit possible de créer CStringT des instances qui contiennent des caractères null incorporés, nous vous recommandons de le faire. L’appel de méthodes et d’opérateurs sur CStringT des objets qui contiennent des caractères null incorporés peut produire des résultats inattendus.

Exemple

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

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

CStringT::operator ==

Détermine si deux chaînes sont logiquement égales.

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

Paramètres

ch1
Caractère ANSI ou Unicode pour la comparaison.

ch2
Caractère ANSI ou Unicode pour la comparaison.

str1
À CStringT des fins de comparaison.

str2
À CStringT des fins de comparaison.

psz1
Pointeur vers une chaîne terminée par null pour la comparaison.

psz2
Pointeur vers une chaîne terminée par null pour la comparaison.

Notes

Teste si une chaîne ou un caractère sur le côté gauche est égal à une chaîne ou un caractère sur le côté droit, et retourne ou FALSE en TRUE conséquence.

Exemple

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

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

CStringT::operator !=

Détermine si deux chaînes ne sont pas égales logiquement.

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

Paramètres

ch1
Caractère ANSI ou Unicode à concaténer avec une chaîne.

ch2
Caractère ANSI ou Unicode à concaténer avec une chaîne.

str1
À CStringT des fins de comparaison.

str2
À CStringT des fins de comparaison.

psz1
Pointeur vers une chaîne terminée par null pour la comparaison.

psz2
Pointeur vers une chaîne terminée par null pour la comparaison.

Notes

Teste si une chaîne ou un caractère situé à gauche n’est pas égal à une chaîne ou un caractère situé à droite.

Exemple

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

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

CStringT::operator <

Détermine si la chaîne située à gauche de l’opérateur est inférieure à la chaîne située à droite.

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

Paramètres

str1
À CStringT des fins de comparaison.

str2
À CStringT des fins de comparaison.

psz1
Pointeur vers une chaîne terminée par null pour la comparaison.

psz2
Pointeur vers une chaîne terminée par null pour la comparaison.

Notes

Comparaison lexicographique entre les chaînes, caractère par caractère jusqu’à :

  • Elle trouve deux caractères correspondants inégaux et le résultat de leur comparaison est considéré comme étant le résultat de la comparaison entre les chaînes.

  • Elle ne trouve aucune inégalité, mais une chaîne a plus de caractères que l’autre, et la chaîne la plus courte est considérée comme inférieure à la chaîne la plus longue.

  • Elle ne trouve aucune inégalité et les chaînes ont le même nombre de caractères, si bien que les chaînes sont égales.

Exemple

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

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

CStringT::operator >

Détermine si la chaîne située à gauche de l’opérateur est supérieure à la chaîne située à droite.

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

Paramètres

str1
À CStringT des fins de comparaison.

str2
À CStringT des fins de comparaison.

psz1
Pointeur vers une chaîne terminée par null pour la comparaison.

psz2
Pointeur vers une chaîne terminée par null pour la comparaison.

Notes

Comparaison lexicographique entre les chaînes, caractère par caractère jusqu’à :

  • Elle trouve deux caractères correspondants inégaux et le résultat de leur comparaison est considéré comme étant le résultat de la comparaison entre les chaînes.

  • Elle ne trouve aucune inégalité, mais une chaîne a plus de caractères que l’autre, et la chaîne la plus courte est considérée comme inférieure à la chaîne la plus longue.

  • Elle ne trouve aucune inégalité et les chaînes ont le même nombre de caractères, si bien que les chaînes sont égales.

Exemple

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

CStringT::operator <=

Détermine si la chaîne située à gauche de l’opérateur est inférieure ou égale à la chaîne située à droite.

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

Paramètres

str1
À CStringT des fins de comparaison.

str2
À CStringT des fins de comparaison.

psz1
Pointeur vers une chaîne terminée par null pour la comparaison.

psz2
Pointeur vers une chaîne terminée par null pour la comparaison.

Notes

Comparaison lexicographique entre les chaînes, caractère par caractère jusqu’à :

  • Elle trouve deux caractères correspondants inégaux et le résultat de leur comparaison est considéré comme étant le résultat de la comparaison entre les chaînes.

  • Elle ne trouve aucune inégalité, mais une chaîne a plus de caractères que l’autre, et la chaîne la plus courte est considérée comme inférieure à la chaîne la plus longue.

  • Elle ne trouve aucune inégalité et les chaînes ont le même nombre de caractères, si bien que les chaînes sont égales.

Exemple

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

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

CStringT::operator >=

Détermine si la chaîne située à gauche de l’opérateur est supérieure ou égale à la chaîne située à droite.

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

Paramètres

str1
À CStringT des fins de comparaison.

str2
À CStringT des fins de comparaison.

psz1
Pointeur vers une chaîne pour la comparaison.

psz2
Pointeur vers une chaîne pour la comparaison.

Notes

Comparaison lexicographique entre les chaînes, caractère par caractère jusqu’à :

  • Elle trouve deux caractères correspondants inégaux et le résultat de leur comparaison est considéré comme étant le résultat de la comparaison entre les chaînes.

  • Elle ne trouve aucune inégalité, mais une chaîne a plus de caractères que l’autre, et la chaîne la plus courte est considérée comme inférieure à la chaîne la plus longue.

  • Elle ne trouve aucune inégalité et les chaînes ont le même nombre de caractères, si bien que les chaînes sont égales.

Exemple

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

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

CStringT::Remove

Supprime toutes les instances du caractère spécifié de la chaîne.

int Remove(XCHAR chRemove);

Paramètres

chRemove
Caractère à supprimer d’une chaîne.

Valeur de retour

Nombre de caractères supprimés de la chaîne. Zéro si la chaîne n’est pas modifiée.

Notes

Les comparaisons pour le caractère respectent la casse.

Exemple

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

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

CStringT::Replace

Il existe deux versions de Replace. La première version remplace une ou plusieurs copies d’une sous-chaîne à l’aide d’une autre sous-chaîne. Les deux sous-chaînes sont terminées par null. La deuxième version remplace une ou plusieurs copies d’un caractère à l’aide d’un autre caractère. Les deux versions fonctionnent sur les données de caractères stockées dans CStringT.

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

Paramètres

pszOld
Pointeur vers une chaîne terminée par null à remplacer par pszNew.

pszNew
Pointeur vers une chaîne terminée par null qui remplace pszOld.

chOld
Caractère à remplacer par chNew.

chNew
Caractère remplaçant chOld.

Valeur de retour

Retourne le nombre d’instances remplacées du caractère ou de la sous-chaîne, ou zéro si la chaîne n’est pas modifiée.

Notes

Replace peut modifier la longueur de la chaîne, car pszNew et pszOld n’ont pas besoin d’être de la même longueur, et plusieurs copies de l’ancienne sous-chaîne peuvent être remplacées par la nouvelle. La fonction effectue une correspondance sensible à la casse.

Exemples d’instances CStringT : CString, CStringAet CStringW.

Pour CStringA, Replace fonctionne avec des caractères ANSI ou multioctets (Mo CS). Pour CStringW, Replace fonctionne avec des caractères larges.

Pour CString, le type de données caractère est sélectionné au moment de la compilation, selon que les constantes du tableau suivant sont définies.

Constante définie Type de données caractère
_UNICODE Caractères larges
_MBCS Caractères multioctets
Aucun Caractères d’un octet
Les deux Undefined

Exemple

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

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

CStringT::ReverseFind

Recherche cet CStringT objet pour la dernière correspondance d’un caractère.

int ReverseFind(XCHAR ch) const throw();

Paramètres

ch
Caractère à rechercher.

Valeur de retour

Index de base zéro du dernier caractère de cet CStringT objet qui correspond au caractère demandé, ou -1 si le caractère est introuvable.

Notes

La fonction est similaire à la fonction strrchrd’exécution .

Exemple

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

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

Extrait les derniers caractères (c’est-à-dire les plus à droite) nCount de cet CStringT objet et retourne une copie de la sous-chaîne extraite.

CStringT Right(int nCount) const;

Paramètres

nCount
Nombre de caractères à extraire de cet objet CStringT.

Valeur de retour

Objet CStringT qui contient une copie de la plage spécifiée des caractères. L’objet retourné CStringT peut être vide.

Notes

Si nCount elle dépasse la longueur de la chaîne, la chaîne entière est extraite. Right est similaire à la fonction De base Right (sauf que les index de Base sont de base zéro).

Pour les jeux de caractères multioctets (MBCS), nCount fait référence à chaque caractère 8 bits ; autrement dit, un octet de prospect et de fin dans un caractère multioctet est compté comme deux caractères.

Exemple

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

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

CStringT::SetSysString

Réalloue le BSTR pointé vers pbstr et copie le contenu de l’objet CStringT dans celui-ci, y compris le NULL caractère.

BSTR SetSysString(BSTR* pbstr) const;

Paramètres

pbstr
Pointeur vers une chaîne de caractères.

Valeur de retour

La nouvelle chaîne.

Notes

Selon le contenu de l’objet CStringT , la valeur de l’objet BSTR référencée pbstr peut changer. La fonction lève une CMemoryException mémoire si insuffisante existe.

Cette fonction est normalement utilisée pour modifier la valeur des chaînes passées par référence pour Automation.

Exemple

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

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

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

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

CStringT::SpanExcluding

Extrait les caractères de la chaîne, en commençant par le premier caractère, qui ne figurent pas dans l’ensemble de caractères identifiés par pszCharSet.

CStringT SpanExcluding(PCXSTR pszCharSet) const;

Paramètres

pszCharSet
Chaîne interprétée comme un ensemble de caractères.

Valeur de retour

Sous-chaîne qui contient des caractères dans la chaîne qui ne se trouvent pas pszCharSet, commençant par le premier caractère de la chaîne et se terminant par le premier caractère trouvé dans la chaîne qui se trouve également pszCharSet (autrement dit, en commençant par le premier caractère de la chaîne et jusqu’à l’exclusion du premier caractère de la chaîne trouvée pszCharSet). Elle retourne la chaîne entière si aucun caractère pszCharSet n’est trouvé dans la chaîne.

Notes

SpanExcluding extrait et retourne tous les caractères qui précèdent la première occurrence d’un caractère pszCharSet (en d’autres termes, le caractère de pszCharSet et tous les caractères suivants dans la chaîne, ne sont pas retournés). Si aucun caractère n’est pszCharSet trouvé dans la chaîne, SpanExcluding retourne la chaîne entière.

Exemple

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

CAtlString src(_T("World Cup '98"));

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

CStringT::SpanIncluding

Extrait les caractères de la chaîne, en commençant par le premier caractère, qui se trouvent dans l’ensemble de caractères identifiés par pszCharSet.

CStringT SpanIncluding(PCXSTR pszCharSet) const;

Paramètres

pszCharSet
Chaîne interprétée comme un ensemble de caractères.

Valeur de retour

Sous-chaîne qui contient des caractères dans la chaîne qui se trouvent pszCharSet, en commençant par le premier caractère de la chaîne et se terminant lorsqu’un caractère est trouvé dans la chaîne qui n’est pas dans pszCharSet. SpanIncluding retourne une sous-chaîne vide si le premier caractère de la chaîne n’est pas dans le jeu spécifié.

Notes

Si le premier caractère de la chaîne n’est pas dans le jeu de caractères, SpanIncluding retourne une chaîne vide. Sinon, elle retourne une séquence de caractères consécutifs qui se trouvent dans le jeu.

Exemple

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

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

CStringT::Tokenize

Recherche le jeton suivant dans une chaîne cible

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

Paramètres

pszTokens
Chaîne contenant des délimiteurs de jetons. L’ordre de ces délimiteurs n’est pas important.

iStart
Index de base zéro pour commencer la recherche.

Valeur de retour

Objet CStringT contenant la valeur du jeton actuel.

Notes

La Tokenize fonction recherche le jeton suivant dans la chaîne cible. Le jeu de caractères dans pszTokens spécifie les délimiteurs possibles du jeton à trouver. Sur chaque appel à la fonction commence à TokenizeiStart, ignore les délimiteurs principaux et retourne un CStringT objet contenant le jeton actuel, qui est la chaîne de caractères jusqu’au caractère délimiteur suivant. La valeur de iStart cette propriété est mise à jour pour être la position suivant le caractère délimiteur de fin, ou -1 si la fin de la chaîne a été atteinte. D’autres jetons peuvent être décomposés du reste de la chaîne cible par une série d’appels à Tokenize, en utilisant iStart pour effectuer le suivi de l’emplacement où dans la chaîne, le jeton suivant doit être lu. Lorsqu’il n’y a plus de jetons, la fonction retourne une chaîne vide et iStart est définie sur -1.

Contrairement aux fonctions de tokenize CRT telles que strtok_s, _wcstok_s_lwcstok_s_strtok_s_l_mbstok_s, , ne Tokenize_mbstok_s_lmodifie pas la chaîne cible.

Exemple

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

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

La sortie de cet exemple est la suivante :

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

CStringT::Trim

Supprime les caractères de début et de fin de la chaîne.

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

Paramètres

chTarget
Caractère cible à découper.

pszTargets
Pointeur vers une chaîne contenant les caractères cibles à découper. Toutes les occurrences de début et de fin des caractères dans pszTargets devront être supprimées de l’objet CStringT .

Valeur de retour

Retourne la chaîne rogné.

Notes

Supprime toutes les occurrences de début et de fin de l’une des opérations suivantes :

  • Caractère spécifié par chTarget.

  • Tous les caractères trouvés dans la chaîne spécifiée par pszTargets.

  • Espaces.

Exemple

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

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

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

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

La sortie de cet exemple est la suivante :

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

CStringT::TrimLeft

Supprime les caractères de début de la chaîne.

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

Paramètres

chTarget
Caractère cible à découper.

pszTargets
Pointeur vers une chaîne contenant les caractères cibles à découper. Toutes les occurrences principales de caractères sont pszTargets supprimées de l’objet CStringT .

Valeur de retour

Chaîne tronquée résultante.

Notes

Supprime toutes les occurrences de début et de fin de l’une des opérations suivantes :

  • Caractère spécifié par chTarget.

  • Tous les caractères trouvés dans la chaîne spécifiée par pszTargets.

  • Espaces.

Exemple

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

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

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

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

CStringT::TrimRight

Supprime les caractères de fin de la chaîne.

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

Paramètres

chTarget
Caractère cible à découper.

pszTargets
Pointeur vers une chaîne contenant les caractères cibles à découper. Toutes les occurrences de fin de caractères sont pszTargets supprimées de l’objet CStringT .

Valeur de retour

Retourne l’objet CStringT qui contient la chaîne rogné.

Notes

Supprime les occurrences de fin de l’une des opérations suivantes :

  • Caractère spécifié par chTarget.

  • Tous les caractères trouvés dans la chaîne spécifiée par pszTargets.

  • Espaces.

La CStringT& TrimRight(XCHAR chTarget) version accepte un paramètre de caractère et supprime toutes les copies de ce caractère de la fin des données de CStringT chaîne. Elle commence à partir de la fin de la chaîne et fonctionne vers l’avant. Il s’arrête lorsqu’il trouve un caractère différent ou lorsqu’il CStringT manque des données de caractères.

La CStringT& TrimRight(PCXSTR pszTargets) version accepte une chaîne terminée par null qui contient tous les caractères différents à rechercher. Elle supprime toutes les copies de ces caractères dans l’objet CStringT . Elle commence à la fin de la chaîne et fonctionne vers l’avant. Il s’arrête lorsqu’il trouve un caractère qui n’est pas dans la chaîne cible ou lorsqu’il CStringT manque des données de caractères. Il n’essaie pas de faire correspondre la chaîne cible entière à une sous-chaîne à la fin de CStringT.

La CStringT& TrimRight() version ne nécessite aucun paramètre. Il supprime les espaces blancs de fin de la fin de la CStringT chaîne. Les espaces blancs peuvent être des sauts de ligne, des espaces ou des onglets.

Exemple

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

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

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

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

Voir aussi

Graphique hiérarchique
Classes partagées ATL/MFC
CSimpleStringT Classe