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

There shall be no explicit floating-integral conversions of a cvalue expression

Description

Rule Definition

There shall be no explicit floating-integral conversions of a cvalue expression.

Rationale

Expressions flagged by this checker follow the detailed specifications for cvalue expressions from the MISRA™ C++ documentation.

If you evaluate an expression and later cast the result to a different type, the cast has no effect on the underlying type of the evaluation (the widest of operand data types in the expression). For instance, in this example, the result of an integer division is then cast to a floating-point type.

short num;
short den;
float res;
res= static_cast<float> (num/den);

However, a developer or code reviewer can expect that the evaluation uses the data type to which the result is cast later. For instance, one can expect a floating-point division because of the later cast.

Additional Message in Report

There shall be no explicit floating-integral conversions of a cvalue expression.

Complex expression of underlying type typeBeforeConversion may only be cast to narrower integer type of same signedness, however the destination type is typeAfterconversion.

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

Conversion of Division Result from Integer to Floating Point

void func() {
     short num;
     short den;
     short res_short;
     float res_float;
     
     res_float = static_cast<float> (num/den); //Noncompliant
     
     res_short = num/den;
     res_float = static_cast<float> (res_short); //Compliant

}

In this example, the first cast on the division result violates the rule but the second cast does not.

• The first cast can lead to the incorrect expectation that the expression is evaluated with an underlying type float.

• The second cast makes it clear that the expression is evaluated with the underlying type short. The result is then cast to the type float.

Check Information

Group: Expressions

Category: Required

Version History

Introduced in R2013b

R2022a: Checker no longer considers function calls as cvalue-expressions

The rule checker no longer considers function calls to be cvalue-expressions. For instance:

class A {
public:
	double memFunc() const;
	void foo();
};

void rateControl::foo() {
	static_cast<int>(memFunc());//Compliant
	//...	
} 

In the body of the function foo(), return value of the call to A::memfunc() is a double. This return value is cast to int. Because function calls are not cvalue expressions, the rule checker does not flag this operation.