Les nouveaux types de données
Il existe trois classes de nouveaux types de données : les types entiers à précision fixe, les types entiers de précision de pointeur et les types de pointeurs de précision spécifique. Ces types ont été ajoutés à l’environnement Windows (en particulier à Basetsd.h) pour permettre aux développeurs de se préparer à Windows 64 bits bien avant son introduction. Ces nouveaux types ont été dérivés de l’entier de base en langage C et des types longs, de sorte qu’ils fonctionnent dans le code existant. Par conséquent, utilisez ces types de données dans votre code maintenant, testez votre code sur Windows 32 bits et utilisez le compilateur 64 bits pour rechercher et résoudre les problèmes de portabilité à l’avance, afin que votre pilote puisse être prêt lorsque Windows 64 bits est disponible pour le test.
En outre, l’adoption de ces nouveaux types de données rendra votre code plus robuste. Pour utiliser ces types de données, vous devez analyser votre code à la recherche d’une utilisation de pointeur, d’un polymorphisme et de définitions de données potentiellement dangereux. Pour être sûr, utilisez les nouveaux types. Par exemple, lorsqu’une variable est de type ULONG_PTR, il est clair qu’elle sera utilisée pour le cast de pointeurs pour les opérations arithmétiques ou le polymorphisme. Il n’est pas possible d’indiquer une telle utilisation directement à l’aide des types de données Win32 natifs. Vous pouvez le faire à l’aide d’un nommage de type dérivé ou d’une notation hongroise, mais les deux techniques sont sujettes à des erreurs.
types entiers Fixed-Precision
Les types de données à précision fixe ont la même longueur pour la programmation 32 bits et 64 bits. Pour vous en souvenir, leur précision fait partie du nom du type de données. Voici les types de données de précision fixe.
| Type | Définition |
|---|---|
DWORD32 |
Entier non signé 32 bits |
DWORD64 |
Entier non signé 64 bits |
INT32 |
Entier 32 bits signé |
INT64 |
Entier 64 bits signé |
LONG32 |
Entier 32 bits signé |
LONG64 |
Entier 64 bits signé |
UINT32 |
INT32 non signé |
UINT64 |
INT64 non signé |
ULONG32 |
LONG32 non signé |
ULONG64 |
LONG64 non signé |
types entiers Pointer-Precision
À mesure que la précision du pointeur change (c’est-à-dire qu’elle devient 32 bits lorsqu’elle est compilée pour les plateformes 32 bits, 64 bits lorsqu’elle est compilée pour les plateformes 64 bits), ces types de données reflètent la précision en conséquence. Par conséquent, il est sûr de convertir un pointeur vers l’un de ces types lors de l’exécution de l’arithmétique du pointeur ; si la précision du pointeur est de 64 bits, le type est 64 bits. Les types de nombre reflètent également la taille maximale à laquelle un pointeur peut faire référence. Voici les types de précision de pointeur et de nombre.
| Type | Définition |
|---|---|
DWORD_PTR |
Type long non signé pour la précision du pointeur. |
HALF_PTR |
Type intégral signé pour la précision des demi-pointeurs (16 bits sur les systèmes 32 bits, 32 bits sur les systèmes 64 bits). |
INT_PTR |
Type intégral signé pour la précision du pointeur. |
LONG_PTR |
Type long signé pour la précision du pointeur. |
SIZE_T |
Nombre maximal d’octets auxquels un pointeur peut faire référence. Utilisez ce type pour un nombre qui doit s’étendre sur toute la plage d’un pointeur. |
SSIZE_T |
SIZE_T signé. |
UHALF_PTR |
HALF_PTR non signé. |
UINT_PTR |
INT_PTR non signé. |
ULONG_PTR |
LONG_PTR non signé. |
Fixed-Precision types de pointeurs
Il existe également de nouveaux types de pointeurs qui dimensionne explicitement le pointeur. Soyez prudent lorsque vous utilisez ces types de pointeurs dans du code 64 bits : si vous déclarez le pointeur à l’aide d’un type 32 bits, le système crée le pointeur en tronquant un pointeur 64 bits.
| Type | Définition |
|---|---|
POINTER_32 |
Pointeur 32 bits. Sur un système 32 bits, il s’agit d’un pointeur natif. Sur un système 64 bits, il s’agit d’un pointeur 64 bits tronqué. |
POINTER_64 |
Pointeur 64 bits. Sur un système 64 bits, il s’agit d’un pointeur natif. Sur un système 32 bits, il s’agit d’un pointeur 32 bits étendu aux signes. Notez qu’il n’est pas sûr de supposer l’état du bit de pointeur élevé. |
Fonctions d’assistance
Les fonctions inline suivantes (définies dans Basetsd.h) peuvent vous aider à convertir en toute sécurité des valeurs d’un type à un autre :
unsigned long HandleToUlong( const void *h )
long HandleToLong( const void *h )
void * LongToHandle( const long h )
unsigned long PtrToUlong( const void *p )
unsigned int PtrToUint( const void *p )
unsigned short PtrToUshort( const void *p )
long PtrToLong( const void *p )
int PtrToInt( const void *p )
short PtrToShort( const void *p )
void * IntToPtr( const int i )
void * UIntToPtr( const unsigned int ui )
void * LongToPtr( const long l )
void * ULongToPtr( const unsigned long ul )
WarningIntToPtr sign-extends the int value, UIntToPtr zero-extends the unsigned int value, LongToPtr sign-extends the long value, and ULongToPtr zero-extends the unsigned long value.