# V204\. Explicit conversion from 32\-bit integer type to pointer 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 32\-bit integer type to a pointer type\. The V201 diagnostic rule used to detect such behavior, but explicit conversion of the int type to a pointer is much more dangerous than conversion of 'int' to intptr\_t\. 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;
...
ptr = (float *)(n);
```

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 at low\-order addresses in 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/) like `size_t`, `ptrdiff_t`, `intptr_t`, or `uintptr_t`\.

This is the correct code:

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

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://docs.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 )
```