Partilhar via


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 .