Outils

Cette rubrique décrit les outils disponibles pour préparer votre application à être compatible 64 bits. Windows 10 est disponible pour les processeurs x64 et ARM64.

Inclure des fichiers

Les éléments d’API sont pratiquement identiques entre Windows 32 et 64 bits. Les fichiers d’en-tête Windows ont été modifiés afin qu’ils puissent être utilisés pour le code 32 et 64 bits. Les nouveaux types et macros 64 bits sont définis dans un nouveau fichier d’en-tête, Basetsd.h, qui se trouve dans l’ensemble de fichiers d’en-tête inclus par Windows.h. Basetsd.h inclut les nouvelles définitions de type de données pour faciliter l’indépendance de la taille du code source.

Nouveaux types de données

Les fichiers d’en-tête Windows contiennent de nouveaux types de données. Ces types sont principalement destinés à la compatibilité de type avec les types de données 32 bits. Les nouveaux types fournissent exactement le même typage que les types existants, tout en assurant la prise en charge de Windows 64 bits. Pour plus d’informations, consultez Le nouveau type de données ou le fichier d’en-tête Basetsd.h.

Macros prédéfinies

Le compilateur définit les macros suivantes pour identifier la plateforme.

Les macros suivantes sont spécifiques à l’architecture.

N’utilisez pas ces macros, à l’exception du code spécifique à l’architecture, utilisez plutôt _WIN64, _WIN32 et _WIN16 dans la mesure du possible.

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 en un autre.

void            * Handle64ToHandle( const void * POINTER_64 h ) 
void * POINTER_64 HandleToHandle64( const void *h )
long              HandleToLong(     const void *h )
unsigned long     HandleToUlong(    const void *h )
void            * IntToPtr(         const int i )
void            * LongToHandle(     const long h )
void            * LongToPtr(        const long l )
void            * Ptr64ToPtr(       const void * POINTER_64 p )
int               PtrToInt(         const void *p )
long              PtrToLong(        const void *p )
void * POINTER_64 PtrToPtr64(       const void *p )
short             PtrToShort(       const void *p )
unsigned int      PtrToUint(        const void *p )
unsigned long     PtrToUlong(       const void *p )
unsigned short    PtrToUshort(      const void *p )
void            * UIntToPtr(        const unsigned int ui )
void            * ULongToPtr(       const unsigned long ul )

Compilateur 64 bits

Les compilateurs 64 bits peuvent être utilisés pour identifier la troncature de pointeur, les casts de type incorrects et d'autres problèmes spécifiques aux 64 bits.

Lorsque le compilateur est exécuté pour la première fois, il génère probablement de nombreux avertissements de troncation de pointeur ou d’incompatibilité de type, tels que les suivants :

warning C4311: 'type cast' : pointer truncation from 'unsigned char *' to 'unsigned long '

Utilisez ces avertissements comme guide pour rendre le code plus robuste. Une bonne pratique consiste à éliminer tous les avertissements, en particulier les avertissements de troncature de pointeur.

Options et avertissements du compilateur 64 bits

Notez que ce compilateur active le modèle de données LLP64.

Il existe une option d’avertissement pour faciliter le portage vers LLP64. Le commutateur -Wp64 -W3 active les avertissements suivants :

• C4305 : Avertissement de troncature. Par exemple, « return » : troncature de « unsigned int64 » en « long ».
• C4311 : Avertissement de troncature. Par exemple, « type cast » : troncature du pointeur de « int*_ptr64 » à « int ».
• C4312 : Avertissement de conversion à une taille supérieure. Par exemple, « type cast » : conversion de « int » en « int*_ptr64 » de taille supérieure.
• C4318 : Passage d'une longueur nulle. Par exemple, en passant une constante zéro comme longueur à la fonction memset.
• C4319 : Pas d'opérateur. Par exemple, « ~ » : extension nulle de « unsigned long » vers « unsigned _int64 » de taille supérieure.
• C4313 : Appel de la famille de fonctions printf avec des spécificateurs de type de conversion et des arguments contradictoires. Par exemple, « printf » : «%p» dans la chaîne de format est en conflit avec l’argument 2 de type « _int64 ». Un autre exemple est l’appel printf( »%x« , pointer_value) ; cela provoque une troncation des 32 bits supérieurs. L’appel correct est printf( »%p« , pointer_value).
• C4244 : identique à l’avertissement C4242 existant. Par exemple, « return » : conversion de « _int64 » en « int non signé », perte possible de données.

Liaison et bibliothèques 64 bits

Pour générer des applications, utilisez l’éditeur de liens et les bibliothèques fournis par le Kit de développement logiciel (SDK) Windows. La plupart des bibliothèques 32 bits ont une version 64 bits correspondante, mais certaines bibliothèques héritées sont disponibles uniquement dans les versions 32 bits. Le code qui appelle ces bibliothèques ne lie pas lorsque l’application est générée pour Windows 64 bits.