Mappages de texte générique dans tchar.h

Pour simplifier le transport du code pour une utilisation internationale, la bibliothèque d’exécution Microsoft fournit des mappages de texte générique spécifiques à Microsoft pour de nombreux types de données, routines et autres objets. Vous pouvez utiliser ces mappages, qui sont définis dans tchar.h, pour écrire du code générique qui peut être compilé pour des jeux de caractères monooctets, multioctets ou Unicode, en fonction d’une constante de manifeste que vous définissez à l’aide d’une #define instruction. Les mappages de texte générique sont des extensions Microsoft non compatibles ANSI.

À l’aide de tchar.h, vous pouvez créer un jeu de caractères multioctets (Mo CS) et des applications Unicode à partir des mêmes sources. tchar.h définit des macros (qui ont le préfixe _tcs) qui, avec les définitions de préprocesseur correctes, mappent à str, _mbsou wcs fonctionnent, selon les besoins. Pour générer Mo CS, définissez le symbole _MBCS. Pour générer Unicode, définissez le symbole _UNICODE. Pour générer une application sur un octet, définissez ni l’un ni l’autre (valeur par défaut). Par défaut, _UNICODE est défini pour les applications MFC.

Le _TCHAR type de données est défini de manière conditionnelle dans tchar.h. Si le symbole _UNICODE est défini pour votre build, _TCHAR est défini comme wchar_t; sinon, pour les builds monooctets et Mo CS, il est défini comme char. (wchar_tle type de données de base unicode à caractères larges est l’équivalent 16 bits d’un signed char.) Pour les applications internationales, utilisez la _tcs famille de fonctions, qui fonctionnent en unités, et non en _TCHAR octets. Par exemple, _tcsncpy les copies n_TCHARs, et non n les octets.

Étant donné que certaines fonctions de gestion des chaînes SBCS (Single Byte Character Set) prennent des paramètres (signés), char* un avertissement du compilateur de type ne correspond pas quand il _MBCS est défini. Il existe trois façons d’éviter cet avertissement :

1. Utilisez les segments de fonction inline type-safe dans tchar.h. C’est le paramétrage par défaut.

2. Utilisez les macros directes dans tchar.h en définissant _MB_MAP_DIRECT sur la ligne de commande. Ce faisant, vous devez associer manuellement les types. Il s’agit de la méthode la plus rapide, mais n’est pas sécurisée par type.

3. Utilisez la fonction de bibliothèque liée statiquement sécurisée de type dans tchar.h. Pour cela, définissez la constante _NO_INLINING sur la ligne de commande. Cette méthode est la plus lente, mais la plus sécurisée pour le type.

Directives de préprocesseur pour les mappages de texte générique

# définir	Version compilée	Exemple
_UNICODE	Unicode (caractères larges)	_tcsrev est mappé à _wcsrev
_MBCS	Caractères multioctets	_tcsrev est mappé à _mbsrev
Aucun (la valeur par défaut n’a ni ni _UNICODE_MBCS défini)	SBCS (ASCII)	_tcsrev est mappé à strrev

Par exemple, la fonction _tcsrevde texte générique, définie dans tchar.h, est mappée si _mbsrev vous avez défini _MBCS dans votre programme ou si _wcsrev vous avez défini _UNICODE. Sinon, _tcsrev est mappée à strrev. D’autres mappages de types de données sont fournis dans tchar.h pour des raisons pratiques de programmation, mais _TCHAR sont les plus utiles.

Mappages de types de données de texte générique

Texte générique Nom du type de données	_UNICODE & _Mo CS non défini	_MBCS Défini	_UNICODE Défini
_TCHAR	char	char	wchar_t
_TINT	int	unsigned int	wint_t
_TSCHAR	signed char	signed char	wchar_t
_TUCHAR	unsigned char	unsigned char	wchar_t
_TXCHAR	char	unsigned char	wchar_t
_T ou _TEXT	Aucun effet (supprimé par le préprocesseur)	Aucun effet (supprimé par le préprocesseur)	L (convertit le caractère ou la chaîne suivant en son équivalent Unicode)

Pour obtenir la liste des mappages de texte générique des routines, des variables et d’autres objets, consultez les mappages de texte générique dans la référence de la bibliothèque d’exécution.

Remarque

N’utilisez pas la str famille de fonctions avec des chaînes Unicode, susceptibles de contenir des octets null incorporés. De même, n’utilisez pas la wcs famille de fonctions avec des chaînes Mo CS (ou SBCS).

Les fragments de code suivants illustrent l’utilisation de _TCHAR et _tcsrev pour le mappage sur les modèles MBCS, Unicode et SBCS.

_TCHAR *RetVal, *szString;
RetVal = _tcsrev(szString);

Si _MBCS elle a été définie, le préprocesseur mappe ce fragment à ce code :

char *RetVal, *szString;
RetVal = _mbsrev(szString);

Si _UNICODE elle a été définie, le préprocesseur mappe ce fragment à ce code :

wchar_t *RetVal, *szString;
RetVal = _wcsrev(szString);

Si aucun n’a été _MBCS_UNICODE défini, le préprocesseur mappe le fragment au code ASCII à un octet, comme suit :

char *RetVal, *szString;
RetVal = strrev(szString);

Par conséquent, vous pouvez écrire, gérer et compiler un fichier de code source unique à exécuter avec des routines spécifiques à l’un des trois types de jeux de caractères.

Voir aussi

Texte et chaînes
Utilisation de types de données TCHAR.H avec _MBCS