MISRA C:2025 Rule 11.4

R2026b

A conversion shall not be performed between a pointer to object and an arithmetic type

Since R2026b

expand all in page

Description

A conversion shall not be performed between a pointer to object and an arithmetic type ¹ .

Rationale

Conversion between integers and pointers can cause errors or undefined behavior.

If an integer is cast to a pointer, the resulting pointer can be incorrectly aligned. The incorrect alignment causes undefined behavior.
If a pointer is cast to an integer, the resulting value can be outside the allowed range for the integer type.

Polyspace Implementation

Casts or implicit conversions from NULL or (void*)0 do not generate a warning.

Conversions between a pointer to object and the types intptr_t or uintptr_t do not result in a violation. These types are designed to hold pointer values and are exceptions to this rule.

Note

If your code converts an absolute address in your hardware to an arithmetic type, Polyspace^® reports a violation on that conversion.

Troubleshooting

If you expect a rule violation but do not see it, refer to Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

expand all

Casts between pointer and integer

#include <stdbool.h>

typedef unsigned char      uint8_t;
typedef          char      char_t;
typedef unsigned short     uint16_t;
typedef signed   int       int32_t;

typedef _Bool bool_t;
uint8_t *PORTA = (uint8_t *) 0x0002;            /* Non-compliant */

void foo(void) {

    char_t c = 1;
    char_t *pc = &c;                              /* Compliant */


    uint16_t ui16   = 7U;
    uint16_t *pui16 = &ui16;                      /* Compliant */
    pui16 = (uint16_t *) ui16;                    /* Non-compliant */


    uint16_t *p;
    int32_t addr = (int32_t) p;                  /* Non-compliant */
    bool_t b = (bool_t) p;                       /* Non-compliant */
    enum etag { A, B } e = ( enum etag ) p;      /* Non-compliant */
}

In this example, the rule is violated when:

The integer 0x0002 is cast to a pointer.
If the integer defines an absolute address, it is more common to assign the address to a pointer in a header file. To avoid the assignment being flagged, you can then exclude headers files from coding rules checking. For more information, see Do not generate results for (-do-not-generate-results-for).
The pointer p is cast to integer types such as int32_t, bool_t or enum etag.

The rule is not violated when the address &ui16 is assigned to a pointer.

Conversions Involving intptr_t and uintptr_t

In this example, conversions between pointers and intptr_t or uintptr_t are compliant because these types are designed to hold pointer values.


#include <stdint.h>

void compliant_exception(void) {
  extern int16_t *ptr;
  uintptr_t uip = (uintptr_t)ptr;    // Compliant
  intptr_t  ip  = (intptr_t)ptr;     // Compliant
  int16_t *p2 = (int16_t *)uip;      // Compliant
  int16_t *p3 = (int16_t *)ip;       // Compliant
}

The types intptr_t and uintptr_t are exceptions to this rule because they are specifically defined to hold pointer values without loss of information.

Check Information

Group: Pointer Type Conversions

Category: Required

AGC Category: Required

PQL Name: std.misra_c_2025.R11_4

Version History

Introduced in R2026b