Partager via

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

  • Article

Pour simplifier le portage du code en vue d’une utilisation internationale, la bibliothèque runtime Microsoft fournit des correspondances 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 codés sur un octet, multioctets ou Unicode, en fonction d’une constante de manifeste que vous définissez en utilisant une instruction #define. Les mappages de texte générique sont des extensions Microsoft non compatibles ANSI.

Avec le fichier d’en-tête tchar.h, vous pouvez créer des applications pour des jeux de caractères codés sur un octet, des jeux de caractères multioctets (MBCS) ou 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 à des fonctions str, _mbs ou wcs, selon ce qui est approprié. Pour générer pour MBCS, définissez le symbole_MBCS. Pour générer pour Unicode, définissez le symbole _UNICODE. Pour générer une application pour le codage sur un octet, ne définissez ni l’un ni l’autre (la valeur par défaut). Par défaut, _UNICODE est défini pour les applications MFC.

Le type de données _TCHAR est défini de manière conditionnelle dans tchar.h. Si le symbole _UNICODE est défini pour votre build, _TCHAR est défini en tant que wchar_t ; sinon, pour les builds pour le codage sur un octet et MBCS, il est défini en tant que char. (wchar_t, le type de données avec caractères larges Unicode de base, est l’équivalent 16 bits d’un caractère signed char de 8 bits .) Pour les applications internationales, utilisez la famille de fonctions _tcs, qui utilisent des unités _TCHAR et non pas des octets. Par exemple, _tcsncpy copie n _TCHARs et non pas n octets.

Comme certaines fonctions de gestion des chaînes SBCS (jeu de caractères codés sur un octet) prennent des paramètres char* (signés), un avertissement du compilateur indiquant une non-correspondance de type est généré quand _MBCS est défini. Il existe trois façons d’éviter cet avertissement :

  1. Utiliser les thunks de fonction inline de type sécurisé dans tchar.h. C’est le paramétrage par défaut.

  2. Utiliser 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. Cette méthode est la plus rapide mais n’est pas de type sécurisé.

  3. Utiliser les thunks de fonction de bibliothèque liée statiquement de type sécurisée 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

# define 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’est définie ni sur _UNICODE ni sur _MBCS) SBCS (ASCII) _tcsrev est mappé à strrev

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

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

Texte générique
Nom du type de données		 _UNICODE &
_MBCS 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 qui suit en son équivalent Unicode)

Pour obtenir une liste complète des mappages de texte générique de routines, variables et autres objets, consultez Mappages de texte générique dans les informations de référence sur la bibliothèque runtime.

Remarque

N’utilisez pas la famille de fonctions str avec des chaînes Unicode, qui sont susceptibles de contenir des octets Null incorporés. De même, n’utilisez pas la famille de fonctions wcs avec des chaînes MBCS (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 a été défini, le préprocesseur mappe ce fragment à ce code :

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

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

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

Si ni _MBCS ni _UNICODE n’ont été définis, le préprocesseur mappe le fragment à un code ASCII sur un seul octet, comme suit :

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

Par conséquent, vous pouvez écrire, maintenir et compiler un fichier de code source unique à exécuter avec des routines qui sont spécifiques à un des trois types de jeu de caractères.

Voir aussi

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