Page History

...

An integer may be converted to any pointer type. Except as previously specified, the result is implementation-defined, might not be correctly aligned, might not point to an entity of the referenced type, and might be a trap representation.

Any pointer type may be converted to an integer type.  Except as previously specified, the result is implementation-defined.  If the result cannot be represented in the integer type, the behavior is undefined.  The result need not be in the range of values of any integer type.

These issues arise because the mapping functions for converting a pointer to an integer or an integer to a pointer must be consistent with the addressing structure of the execution environment.  For example, not all machines have a flat memory model.

It is sometimes necessary in low level kernel or graphics code to access memory at a specific location, requiring a literal integer to pointer conversion such as the following.  It should be recognized that this is specific to a particular type of machine, and should therefore be done only when necessary.

unsigned int *ptr = 0xcfcfcfcf;

Non-Compliant Code Example

In this non-compliant code example, the pointer ptr is used in an arithmetic operation that is eventually converted to an integer value. As previously stated, the result of this assignment and following assignment to ptr2 are implementation-defined  Both a pointer and an int are assumed to be 32 bits.  The upper 9 bits of the number are used to hold a flag value and the result is converted back into a pointer.

char *ptr;
/* ... */
unsigned int number = ptr + 1;
unsigned int *ptr2 = ptr;

Compliant Solution

;
number = (number & 0x7fffff) | (flag << 23);
ptr = number;

A scheme similar to this was actually used in early versions of Emacs, sacrificing its portability and its ability to edit files larger than 8MB.

Compliant Solution

Saving a few bits of storage is not so important that it is worth writing nonportable code.  A struct can be used to provide room for both the pointer and the flag value.  This is portable to machines of different word sizes, both smaller and larger than 32 bits, and works even when pointers cannot be represented in any integer typeA union can be used to give raw memory access to both an integer and a pointer. This is an efficient approach, as the structure only requires as much storage as the larger of the two fields.

unionstruct intpointptrflag {
  unsigned intchar *pointer;
  unsigned int numberflag :9;
} intpointptrflag;
/* ... */
intpoint mydataptrflag.pointer = 0xcfcfcfcfptr;
/* ... */
unsigned int num = mydata.number + 1;
unsigned int *ptr = mydata.pointer;
ptrflag.flag = flag;

Non-Compliant Code Example

It is sometimes necessary in low level kernel or graphics code to access memory at a specific location, requiring a literal integer to pointer to conversion. In this non-compliant code, a pointer is set directly to an integer constant.The following code tries to determine whether two character pointers are aligned to each other.

char *ptr1;
char *ptr2;
/* ... */
if (((unsigned int *ptr = 0xcfcfcfcf;

The result of this assignment is implementation-defined, might not be correctly aligned, might not point to an entity of the referenced type, and might be a trap representation.

Compliant Solution

)ptr1 & 3) == ((unsigned)ptr2 & 3)) {
  /* ... */

Although this is likely to work on many architectures, it does not provide maximum portability.

Compliant Solution

On machines where pointers can be represented as integers, the types intptr_t and uintptr_t are provided for that purpose.  They are only guaranteed to be able to receive void pointersAdding an explicit cast may help the compiler convert the integer value into a valid pointer.

unsigned int *ptr = (unsigned int *)0xcfcfcfcf;
#include <stdint.h>
/* ... */
char *ptr1;
char *ptr2;
/* ... */
if (((uintptr_t)(void *)ptr1 & ALIGN_BITS) == ((uintptr_t)(void *)ptr2 & ALIGN_BITS)) {
  /* ... */

The header inttypes.h can be used instead of stdint.h to get the integer types in a hosted environment.

Risk Analysis

Converting from pointer to integer or vice versa results in unportable code and may create unexpected pointers to invalid memory locations.

...