Nota
O acesso a esta página requer autorização. Pode tentar iniciar sessão ou alterar os diretórios.
O acesso a esta página requer autorização. Pode tentar alterar os diretórios.
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 .