MISRA C++:2008 Rule 5-0-18

>, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same array

Description

Rule Definition

>, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same array.

Rationale

When you compare two pointers to array elements, the result is the positions of the pointers relative to each other. If the pointers are null or point to different arrays, a comparison operation is undefined.

Before you use >, >=, <, or <= between pointers to array elements, check that they are non-null and that they point to the same array.

Polyspace Implementation

Polyspace^® flags the use of >, >=, <, or <= operators between pointers to elements of different arrays.

Troubleshooting

If you expect a rule violation but Polyspace does not report it, see Diagnose Why Coding Standard Violations Do Not Appear as Expected.

Examples

Avoid Comparing Pointers to Elements of Different Arrays

bool foo(){
	int a[10];
	int b[10];
	return (a<b); //Noncompliant
	
}

In this example, Polyspace flags the comparison between a and b, which are elements of different arrays.

Check Information

Group: Expressions

Category: Required

Version History

Introduced in R2013b

R2023a: Checker no longer flags comparison of integers that are cast from pointers

The rule checker no longer reports violations of this rule when you compare integers that are cast from pointers.

R2023a: Pointer comparison involving outputs of stubbed function no longer ignored

Polyspace reports violations of this rule even if you use the output of a stubbed function to perform a pointer comparison operation. For instance, in this code, the pointer ptr is returned by the function get_ptr():

int32_t *ptr = get_ptr ( );
int32_t a1[ 10 ];
int32_t *p1 = &a1[ 1 ];
bool loc = ptr > p1;   //Noncompliant

Because the function get_ptr() lacks a body, Polyspace treats it as a stubbed function. Polyspace no longer ignores pointer arithmetic operations when one of the operands is the output of the stubbed function. In this case, because get_ptr() is called before p1 is declared, the pointers ptr and p1 cannot point to the same array. Polyspace reports a violation.