Pourquoi « int64_t » se comporte-t-il différemment dans les compilations GCC 64 bits ?

Long Long Int vs. Long Int vs. Int64_t en C

Les traits de type C peuvent présenter un comportement bizarre, en particulier avec les 64 bits signés types entiers. Voici pourquoi :

Dans les compilations 32 bits et 64 bits (GCC et MSVC), le programme suivant se comporte comme prévu :

<code class="cpp">#include <iostream>
#include <cstdint>

template <typename T>
bool is_int64() { return false; }

template <>
bool is_int64<int64_t>() { return true; }

int main()
{
    std::cout << "int:\t" << is_int64<int>() << std::endl;
    std::cout << "int64_t:\t" << is_int64<int64_t>() << std::endl;
    std::cout << "long int:\t" << is_int64<long int>() << std::endl;
    std::cout << "long long int:\t" << is_int64<long long int>() << std::endl;

    return 0;
}</code>

La sortie indique correctement que int64_t , long int et long long int sont tous des types entiers 64 bits équivalents.

Cependant, une compilation GCC 64 bits produit un résultat différent :

int:           0
int64_t:       1
long int:      1
long long int: 0

Ce comportement surprenant provient de la définition de la bibliothèque standard C de int64_t :

<code class="cpp"># if __WORDSIZE == 64
typedef long int  int64_t;
# else
__extension__
typedef long long int  int64_t;
# endif</code>

Dans une compilation 64 bits, int64_t est défini comme long int, et non comme long long int. Cela signifie que la spécialisation de modèle is_int64() qui vérifie int64_t correspondra à long int au lieu de long long int.

Solution utilisant la spécialisation de modèle partielle :

Pour résoudre ce problème problème, vous pouvez utiliser une spécialisation partielle de modèle pour définir explicitement is_int64() pour long long int :

<code class="cpp">#if defined(__GNUC__) && (__WORDSIZE == 64)
template <>
bool is_int64<long long int>() { return true; }
#endif</code>

Cependant, cette solution dépend du compilateur et peut être fastidieuse à mettre en œuvre pour chaque type affecté.

Solution alternative utilisant Boost :

Boost fournit une solution plus élégante avec le modèle variadique boost::is_same :

<code class="cpp">#include <boost/type_traits/is_same.hpp>

template <typename T>
bool is_int64_boost() { return boost::is_same<T, int64_t>::value; }

int main()
{
    std::cout << "int:\t" << is_int64_boost<int>() << std::endl;
    std::cout << "int64_t:\t" << is_int64_boost<int64_t>() << std::endl;
    std::cout << "long int:\t" << is_int64_boost<long int>() << std::endl;
    std::cout << "long long int:\t" << is_int64_boost<long long int>() << std::endl;

    return 0;
}</code>

Cette approche identifiera correctement tous les types entiers 64 bits équivalents, quelle que soit leur représentation exacte dans la bibliothèque standard.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!