Os novos tipos de dados

Há três classes de novos tipos de dados: tipos inteiros de precisão fixa, tipos inteiros de precisão de ponteiro, e tipos de ponteiro com precisão específica. Esses tipos foram adicionados ao ambiente Windows (especificamente, ao Basetsd.h) para permitir que os desenvolvedores se preparem para o Windows de 64 bits bem antes de sua introdução. Esses novos tipos foram derivados do inteiro básico da linguagem C e dos tipos longos, portanto, eles funcionam no código existente. Portanto, use esses tipos de dados em seu código agora, teste seu código no Windows de 32 bits e use o compilador de 64 bits para localizar e corrigir problemas de portabilidade com antecedência, para que seu driver possa estar pronto quando o Windows de 64 bits estiver disponível para teste.

Além disso, a adoção desses novos tipos de dados tornará seu código mais robusto. Para usar esses tipos de dados, você deve verificar seu código em busca de uso de ponteiro potencialmente inseguro, polimorfismo e definições de dados. Para estar seguro, use os novos tipos. Por exemplo, quando uma variável é do tipo ULONG_PTR, é claro que ela será usada para lançar ponteiros para operações aritméticas ou polimorfismo. Não é possível indicar esse uso diretamente usando os tipos de dados Win32 nativos. Você pode fazer isso usando nomenclatura de tipo derivada ou notação húngara, mas ambas as técnicas são propensas a erros.

Fixed-Precision Tipos inteiros

Os tipos de dados de precisão fixa têm o mesmo comprimento para programação de 32 bits e 64 bits. Para ajudá-lo a se lembrar disso, sua precisão faz parte do nome do tipo de dados. A seguir estão os tipos de dados de precisão fixa.

Tipo	Definição
DWORD32	Inteiro não assinado de 32 bits
DWORD64	Inteiro não assinado de 64 bits
INT32	Inteiro assinado de 32 bits
INT64	Inteiro assinado de 64 bits
LONGO32	Inteiro assinado de 32 bits
LONGO64	Inteiro assinado de 64 bits
UINT32	Não assinado INT32
UINT64	Não assinado INT64
ULONG32	Não assinado LONG32
ULONG64	Não assinado LONG64

Pointer-Precision Tipos inteiros

À medida que a precisão do ponteiro muda (ou seja, torna-se 32 bits quando compilado para plataformas de 32 bits e 64 bits quando compilado para plataformas de 64 bits), estes tipos de dados refletem a precisão correspondente. Portanto, é seguro lançar um ponteiro para um desses tipos ao fazer operações aritméticas com ponteiros; se a precisão do ponteiro for de 64 bits, então o tipo será de 64 bits. Os tipos de contagem também refletem o tamanho máximo ao qual um ponteiro pode referir-se. A seguir estão os tipos de precisão de ponteiro e tipos de contagem.

Tipo	Definição
DWORD_PTR	Tipo longo não assinado para precisão do ponteiro.
HALF_PTR	Tipo integral assinado para precisão de meio ponteiro (16 bits em sistemas de 32 bits, 32 bits em sistemas de 64 bits).
INT_PTR	Tipo integral assinado para precisão do ponteiro.
LONG_PTR	Tipo longo assinado para precisão do ponteiro.
SIZE_T	O número máximo de bytes aos quais um ponteiro pode se referir. Use esse tipo para uma contagem que deve abranger todo o intervalo de um ponteiro.
SSIZE_T	Assinado SIZE_T.
UHALF_PTR	Não assinado HALF_PTR
UINT_PTR	Não assinado INT_PTR.
ULONG_PTR	Não assinado LONG_PTR.

Fixed-Precision tipos de ponteiro

Há também novos tipos de ponteiro que dimensionam explicitamente o ponteiro. Tenha cuidado ao usar esses tipos de ponteiro no código de 64 bits: Se você declarar o ponteiro usando um tipo de 32 bits, o sistema criará o ponteiro truncando um ponteiro de 64 bits.

Tipo	Definição
POINTER_32	Um ponteiro de 32 bits. Em um sistema de 32 bits, este é um ponteiro nativo. Em um sistema de 64 bits, este é um ponteiro truncado de 64 bits.
POINTER_64	Um ponteiro de 64 bits. Em um sistema de 64 bits, este é um ponteiro nativo. Em um sistema de 32 bits, este é um ponteiro de 32 bits com extensão de sinal. Observe que não é seguro assumir o estado do bit de ponteiro alto.

Funções auxiliares

As seguintes funções embutidas (definidas em Basetsd.h) podem ajudá-lo a converter valores com segurança de um tipo para outro:

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 )

AvisoIntToPtr sign-estende o valor int , UIntToPtr zero-estende o valor int não assinado, LongToPtr sign-estende o valor long e ULongToPtr zero-estende o valor long não assinado .