Type de unsigned long est différente de uint32_t et un uint64_t sur Windows (VS2010)

Sur Visual Studio 2010 sous Windows 7, 32 bits, unsigned long semble être un type distinct de deux uint32_t et un uint64_t. Voir le programme de test suivant:

#include <stdint.h>
#include <stdio.h>

template<class T, class U>
struct is_same_type
{
    static const bool value = false;
};
template<class T>
struct is_same_type<T, T>
{
    static const bool value = true;
};

#define TO_STRING(arg)        TO_STRING_IMPL(arg)
#define TO_STRING_IMPL(arg)   #arg

#define PRINT_SAME_TYPE(type1, type2) printf("%s (size=%d) %s %s (size=%d)\n", \
    TO_STRING(type1), int(sizeof(type1)), \
    is_same_type<type1, type2>::value ? "==" : "!=", \
    TO_STRING(type2), int(sizeof(type2)))


int main(int /*argc*/, const char* /*argv*/[])
{
    PRINT_SAME_TYPE(uint32_t, unsigned long);
    PRINT_SAME_TYPE(uint64_t, unsigned long);
    return 0;
}

Je m'attends à imprimer soit

uint32_t (size=4) != unsigned long (size=8)
uint64_t (size=8) == unsigned long (size=8)

(que je reçois sur Linux x86_64) ou

uint32_t (size=4) == unsigned long (size=4)
uint64_t (size=8) != unsigned long (size=4)

en supposant bien sûr que longue n'est pas plus long que 64bits.

Sur Windows cependant, j'ai l'déconcertant

uint32_t (size=4) != unsigned long (size=4)
uint64_t (size=8) != unsigned long (size=4)

ce qui signifie qu'il y a deux distincts 32 bits non signé types. Est-ce autorisé par la norme C++? Ou est-ce un bug du compilateur Visual C++?

Oui, il y a deux distincts, non signé non signé de 32 bits types. uint32_t est un typedef unsigned int. Et unsigned int != unsigned long.

OriginalL'auteur tbleher | 2012-07-23

  1. 6

    Il y a deux distincts de 32 bits non signé types

    Oui, il y a des. Les deux int et long sont représentés par 32 bits.

    Est-ce autorisé par la norme C++?

    Oui. La spécification des états (C++11 §3.9.1[de base.fondamentaux]/2):

    Il y a cinq standard des entiers signés types : signed char, short int, int, long int, et long long int. Dans cette liste, chaque type offre au moins autant d'espace de stockage que ceux qui le précèdent dans la liste.

    Pour chaque de la norme entier signé types, il existe un correspondant (mais différentes) standard type entier non signé...dont chacun occupe la même quantité de stockage et a le même alignement exigences correspondantes entier signé de type

    Noter que, malgré le fait que int et long sont représentés par le même nombre de bits, ils sont encore différents types (ainsi, par exemple, ils sont traités différemment au cours de la résolution de surcharge).

    Le dernier point est génial pour un peu-de la méta-programmation et préférant certaines surcharges en ayant un prendre un int, l'autre prend un long et le passage d'un littéral 0.
    Merci pour l'explication, je me souviens maintenant 🙂 à Partir d'un point de vue historique c'est logique, mais je trouve toujours ça un peu malheureux aspect du C++ type de système. Dans mon cas, je suis fauché parce que j'ai eu de modèle de surcharges pour tous les int*_t et uint*_t types, mais ils n'ont pas attraper tous les types d'entiers.

    OriginalL'auteur James McNellis