AUTOSAR C++14 Rule A5-2-3

A cast shall not remove any const or volatile qualification from the type of a pointer or reference

Description

A cast shall not remove any const or volatile qualification from the type of a pointer or reference.

Rationale

Removing the const or volatile qualification from a pointer or reference might be unexpected. Consider this code:

void foo(const char* p){
  *const_cast< char * >( p ) = '\0';
}

The function foo() accepts a const pointer to a char. The caller of this functions expects that the parameter p remains unchanged. Modifying p in foo() by converting it to a non-const pointer is unexpected. If *p dereferences to a const character, this modification might lead to unexpected behavior. Avoid casting the const or volatile away from a pointer or reference.

Polyspace Implementation

Polyspace^® raises a violation of this rule if you remove the const or volatile qualification from the type of a pointer or a reference by:

• Casting one pointer to another pointers

• Casting to a reference

.

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 Casting Away Const from Pointers

void foo(const char* p){
  *const_cast< char * >( p ) = '\0';//Noncompliant
}

void foo1(volatile char* p){
  (char*) p ;//Noncompliant
}

In this example, Polyspace flags the casting operations that cast away the const and volatile qualifiers from pointers.

Check Information

Group: Expressions

Category: Required, Automated

PQL Name: std.autosar_cpp14.A5_2_3

Version History

Introduced in R2019a

R2026a: Violation not reported on cast to nonpointer or nonreference object

Polyspace no longer reports a violation when a pointer or reference loses its const or volatile qualifier during a cast to a non-pointer or non-reference type.

R2024b: Violation not reported if CV-qualification is static_cast to void and the output is not used

Polyspace does not report a violation if the const or volatile qualification of an expression is converted to void using static_cast<void> and the result is not used. For example, the CV-qualification of myArray is converted to void and the result is not used. Polyspace does not report a violation.

void func(std::string s, std::array<uint32_t, 4> const & myArray) {
  static_cast<void>(myArray);           // Compliant
}