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 de precisão específica. Esses tipos foram adicionados ao ambiente do 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, 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 o 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 quanto ao uso potencialmente inseguro de ponteiro, polimorfismo e definições de dados. Para ser seguro, use os novos tipos. Por exemplo, quando uma variável é do tipo ULONG_PTR, fica claro que ela será usada para conversão de ponteiros para operações aritméticas ou polimorfismo. Não é possível indicar esse uso diretamente usando os tipos de dados nativos do Win32. Você pode fazer isso usando a nomenclatura de tipo derivado ou a notação húngara, mas ambas as técnicas são propensas a erros.

tipos inteiros Fixed-Precision

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, a precisão deles faz parte do nome do tipo de dados. Veja a seguir os tipos de dados de precisão fixa.

Digite	Definição
DWORD32	Inteiro sem sinal de 32 bits
DWORD64	Inteiro sem sinal de 64 bits
INT32	Inteiro com sinal de 32 bits
INT64	Inteiro com sinal de 64 bits
LONG32	Inteiro com sinal de 32 bits
LONG64	Inteiro com sinal de 64 bits
UINT32	INT32 sem sinal
UINT64	INT64 sem sinal
ULONG32	LONG32 sem sinal
ULONG64	LONG64 sem sinal

tipos inteiros Pointer-Precision

À medida que a precisão do ponteiro muda (ou seja, à medida que se torna 32 bits quando compilado para plataformas de 32 bits, 64 bits quando compilado para plataformas de 64 bits), esses tipos de dados refletem a precisão adequadamente. Portanto, é seguro converter um ponteiro para um desses tipos ao executar a aritmética de ponteiro; se a precisão do ponteiro for de 64 bits, o tipo será de 64 bits. Os tipos de contagem também refletem o tamanho máximo ao qual um ponteiro pode se referir. Veja a seguir os tipos de precisão de ponteiro e contagem.

Digite	Definição
DWORD_PTR	Tipo longo sem sinal para precisão de 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 o intervalo completo de um ponteiro.
SSIZE_T	SIZE_T assinado.
UHALF_PTR	HALF_PTR sem sinal.
UINT_PTR	INT_PTR sem sinal.
ULONG_PTR	LONG_PTR sem sinal.

Tipos de ponteiro Fixed-Precision

Também há novos tipos de ponteiro que dimensionam explicitamente o ponteiro. Tenha cuidado ao usar esses tipos de ponteiro em 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.

Digite	Definição
POINTER_32	Um ponteiro de 32 bits. Em um sistema de 32 bits, esse é um ponteiro nativo. Em um sistema de 64 bits, esse é um ponteiro truncado de 64 bits.
POINTER_64	Um ponteiro de 64 bits. Em um sistema de 64 bits, esse é um ponteiro nativo. Em um sistema de 32 bits, esse é um ponteiro de 32 bits estendido por 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-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.