“Pointer from integer/integer from pointer without a cast” issues

by

No, it is not valid C and has never been valid C. These examples are so-called constraint violations of the standard.

The standard does not allow you to initialize/assign a pointer to an integer, nor an integer to a pointer. You need to manually force a type conversion with a cast:

int* p = (int*) 0x1234;

int i = (int)p;

If you don’t use the cast, the code is not valid C and your compiler is not allowed to let the code pass without displaying a message. The cast operator states: C17 6.5.4/3:

Constraints
/–/
Conversions that involve pointers, other than where permitted by the constraints of 6.5.16.1, shall be specified by means of an explicit cast.

6.5.16.1 being the rules of simple assignment that allow certain implicit conversions of pointers, see C17 6.5.16.1 §1:

6.5.16.1 Simple assignment

Constraints

One of the following shall hold:

  • the left operand has atomic, qualified, or unqualified arithmetic type, and the right has
    arithmetic type;
  • the left operand has an atomic, qualified, or unqualified version of a structure or union type
    compatible with the type of the right;
  • the left operand has atomic, qualified, or unqualified pointer type, and (considering the type
    the left operand would have after lvalue conversion) both operands are pointers to qualified
    or unqualified versions of compatible types, and the type pointed to by the left has all the
    qualifiers of the type pointed to by the right;
  • the left operand has atomic, qualified, or unqualified pointer type, and (considering the type
    the left operand would have after lvalue conversion) one operand is a pointer to an object type,
    and the other is a pointer to a qualified or unqualified version of void, and the type pointed to
    by the left has all the qualifiers of the type pointed to by the right;
  • the left operand is an atomic, qualified, or unqualified pointer, and the right is a null pointer
    constant; or
  • the left operand has type atomic, qualified, or unqualified _Bool, and the right is a pointer.

In case of int* p = 0x12345678;, the left operand is a pointer and the right is an arithmetic type.
In case of int i = p;, the left operand is an arithmetic type and the right is a pointer.
Neither of these fit in with any of the constraints cited above.

As for why int* p = 0; works, it is a special case. The left operand is a pointer and the right is a null pointer constant. More info about the difference between null pointers, null pointer constants and the NULL macro.

Some things of note:

  • If you assign a raw address to a pointer, the pointer likely needs to be volatile qualified, given that it points at something like a hardware register or an EEPROM/Flash memory location, that can change its contents in run-time.

  • Converting a pointer to an integer is by no means guaranteed to work even with the cast. The standard (C17 6.3.2.3 §5 and §6 says):

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. 68)

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.

Informative foot note:

68) The mapping functions for converting a pointer to an integer or an integer to a pointer are intended to be consistent with the addressing structure of the execution environment.

In addition, the address from a pointer might be larger than what will fit inside an int, as is the case for most 64 bit systems. Therefore it is better to use the uintptr_t from <stdint.h>

More Related Contents:

  1. what is meant by (void *) variable and (void *) & variable in C [closed]
  2. printf(“%p”) and casting to (void *)
  3. Should I explicitly cast malloc()’s return value? [duplicate]
  4. What’s the difference between a VLA and dynamic memory allocation via malloc?
  5. casting char[][] to char** causes segfault?
  6. Mis-aligned pointers on x86
  7. Casting a pointer does not produce an lvalue. Why?
  8. Dereferencing this pointer gives me -46, but I am not sure why
  9. What are the rules for casting pointers in C?
  10. How to initialize a pointer to a struct in C?
  11. Pointers program
  12. Are there differences between pointers to object stored on stack and heap? [closed]
  13. With arrays, why is it the case that a[5] == 5[a]?
  14. (Why) is using an uninitialized variable undefined behavior?
  15. Length of array in function argument
  16. How do I understand complicated function declarations?
  17. How can I allocate memory and return it (via a pointer-parameter) to the calling function?
  18. C pointers : pointing to an array of fixed size
  19. Array to pointer decay and passing multidimensional arrays to functions
  20. Why does this code segfault on 64-bit architecture but work fine on 32-bit?
  21. C: Which character should be used for ptrdiff_t in printf?
  22. Why doesn’t scanf need an ampersand for strings and also works fine in printf (in C)?
  23. C – Accessing data AFTER memory has been free()ed?
  24. allocate matrix in C
  25. Getting the size of a malloc only with the returned pointer
  26. When an int is cast to a short and truncated, how is the new value determined?
  27. Can I treat a struct like an array?
  28. Can a “container_of” macro ever be strictly-conforming?
  29. Difference between pointer to pointer and pointer to array?
  30. Is a += b more efficient than a = a + b in C?

Leave a Comment