# V205\. Explicit conversion of pointer type to 32\-bit integer type\.


> This rule belongs to the "Diagnosis of 64\\\-bit errors" group\\\. The rules in this group are no longer developed and may be disabled in the future\\\. If you use these rules, please \[contact our support team\]\(https://pvs\-studio\.com/en/about\-feedback/\)—we will help you find a replacement or suggest an alternative solution\\\.

The analyzer has detected explicit type casting of a pointer type to a 32\-bit integer type\. The V202 diagnostic rule used to detect such behavior, but explicit conversion of a pointer to the int type is much more dangerous than conversion of intptr\_t to int\. So, a separate diagnostic rule to search for explicit type conversions when handling pointers has been created\.

Here is a sample of incorrect code\.

```cpp
int n;
float *ptr;
...
n = (int)ptr;
```

The `int` type is 4 bytes in a 64\-bit program, so it cannot store a pointer of 8 bytes\. Type casting, as shown in the example above, usually indicates an error\.

Such errors are particularly problematic as they may not manifest immediately\. A program can store pointers in 32\-bit variables and work correctly for some time as long as all the objects created in the program are located in low\-order addresses of memory\.

If you need to store a pointer in an integer variable for some reason, use [memsize\-types](https://pvs-studio.com/en/blog/terms/0030/)\. For instance: `size_t`, `ptrdiff_t`, `intptr_t`, `uintptr_t`\.

This is the correct code:

```cpp
intptr_t n;
float *ptr;
...
n = (intptr_t)ptr;
```

However, there is a specific case when you may store a pointer in 32\-bit types—handles, which are used in Windows to work with various system objects\. Here are examples of such types: `HANDLE`, `HWND`, `HMENU`, `HPALETTE`, `HBITMAP`, etc\. They are actually pointers\. For instance, `HANDLE` is defined in header files as `typedef void *HANDLE;`\.

Although descriptors are 64\-bit pointers, they use only 32\-bit low\-order pointers for better compatibility \(for example, to enable interaction between 32\-bit and 64\-bit processes\)\.You can find more details in "[Microsoft Interface Definition Language \(MIDL\): 64\-Bit Porting Guide](https://learn.microsoft.com/en-us/previous-versions/ms810720(v=msdn.10))" \(USER and GDI handles are sign extended 32b values\)\.

Such pointers can be stored in 32\-bit data types \(for instance, `int`, `DWORD`\)\. [Special functions](https://docs.microsoft.com/en-us/windows/win32/winprog64/the-tools) are used to cast such pointers to 32\-bit types and vice versa:

```cpp
void            * Handle64ToHandle( const void * POINTER_64 h ) 
void * POINTER_64 HandleToHandle64( const void *h )
long              HandleToLong    ( const void *h )
unsigned long     HandleToUlong   ( const void *h )
void            * IntToPtr        ( const int i )
void            * LongToHandle    ( const long h )
void            * LongToPtr       ( const long l )
void            * Ptr64ToPtr      ( const void * POINTER_64 p )
int               PtrToInt        ( const void *p )
long              PtrToLong       ( const void *p )
void * POINTER_64 PtrToPtr64      ( const void *p )
short             PtrToShort      ( const void *p )
unsigned int      PtrToUint       ( const void *p )
unsigned long     PtrToUlong      ( const void *p )
unsigned short    PtrToUshort     ( const void *p )
void            * UIntToPtr       ( const unsigned int ui )
void            * ULongToPtr      ( const unsigned long ul )
```

Let's take a look at the following example:

```cpp
HANDLE h = Get();
UINT uId = (UINT)h;
```

The analyzer does not issue the message here, even though `HANDLE` is a pointer\. Its values always fit into 32 bits\. Note that invalid handles are declared as follows:

```cpp
#define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
```

That's why the next line is incorrect:

```cpp
if (HANDLE(uID) == INVALID_HANDLE_VALUE)
```

Since the `uID` variable is unsigned, the pointer value will be 0x00000000FFFFFFFF, not 0xFFFFFFFFFFFFFFFF\.

The analyzer issues the [V204](https://pvs-studio.com/en/docs/warnings/v204/) warning for a suspicious check when unsigned turns into a pointer\.