MISRA Discussion Forums - 6.4 Standard conversions (C++)

Rule 4-5-3 about using relational operators to determine uint8_t

Thu, 08 Dec 2022 08:00:46 +0000

Quote:Exceptionally, the following operators may be used if the associated restriction is observed:
• The binary + operator may be used to add an integral value in the range 0 to 9 to ‘0’;
• The binary – operator may be used to subtract character '0'.
• The relational operators <, <=, >, >= may be used to determine if a character (or wide
character) represents a digit.

According to exceptions and cases of Rule 4-5-3, it seems that Exp1 apples to uint8_t and Exp2, Exp3 apply to character (wide character). And the rule title mainly cares about plain char and wchar_t, so,
1. What about using uint8_t as operands of relational operators?
2. Which kind of cases does uint8_t violate this rule? Does this rule only check binary operator "+" only for uint8_t?

Code:
void f(void)

{

    char ch = 't';

    if (( ch >= '0') && ( ch <= '9')) // Compliant by exception

    {

        v = ch – '0';                 // Compliant by exception

    }

    unsigned char uc;

    if (( uc >= '0') && ( uc <= '9'))  // compliant or non-compliant?

    {

    }

}

R4-5-1 Alternative tokens

Thu, 23 Sep 2021 10:26:27 +0000

Hello,

I have a request for clarification for rule 4-5-1:

Quote:Rule 4–5–1
(Required)
Expressions with type bool shall not be used as operands to built-in operators other than the assignment operator = , the logical operators && , || , ! , the equality operators == and !=, the unary & operator, and the conditional operator.

Rule 4-5-1 and its Rationale do not seem to explicitly forbid the alternative operator representations and, or and not, which, if I understand correctly, are equivalent to the allowed &&, || and !. Rule 2-5-1 explicitly forbids digraphs, but restricts the notion of digraph to the six cases given in its Rationale.

Can I therefore interpret the rule as implicitly allowing and, or and not (and then maybe also not_eq) tokens?

Rule 4-5-1 prohibits 'b1 |= b2;' ?

Wed, 28 Sep 2016 14:00:17 +0000

Neither `|` nor `|=` is listed as allowed operator.
Does this mean the following code a violation of Rule 4-5-1?

Code:
bool b1 = false;

void f(int x)

{

    b1 |= (x == 0);

}

Rule 4-5-1 prohibits sizeof(bool_type_variable)?

Mon, 13 Jun 2016 04:56:23 +0000

According to Rule 4-5-1 sizeof(bool_type_variable) is not allowed, although it is very meaningful in serialization.
Is this intentional?
If so then why?

Resolve Rule 5-0-6: cast to 7 bits struct field

Tue, 12 Aug 2014 15:44:54 +0000

How can resolve next Notes??

Note 1960: Violates MISRA C++ 2008 Required Rule 5-0-6, Implicit conversion of integer to smaller type
Note 1960: Violates MISRA C++ 2008 Required Rule 5-0-3, Implicit conversion of integer cvalue expression

In this assignament:
CTU.EVTCFGR[fTriggerChannel].B.CHANNEL_VALUE = static_cast (fAdcChannel & 0xFFU);

Where CHANNEL_VALUE is:
union { /* Event Config 0..63 (Base+0x0030-0x012C) */
vuint32_t R;
struct {
vuint32_t :16;
vuint32_t TM:1;
vuint32_t CLR_FLAG:1;
vuint32_t :5;
vuint32_t ADC_SEL:1;
vuint32_t :1;
vuint32_t CHANNEL_VALUE:7;
} B;
} EVTCFGR[64];

Thanks in advance

Rule 4-10-2 NULL is not a c++ standard

Fri, 07 Feb 2014 07:34:33 +0000

In C++ Standard, There are not exist NULL(its C standard).
So, Programmer should to know about this and Use constant 0 instead of NULL macro.

Casting pointers & Rule 5-2-7

Tue, 28 Feb 2012 13:38:24 +0000

The 5-2-7 rule says:

Quote:An object with pointer type sall not be converted to an unrelated pointer type, either directly or indirectly

and then shows some examples of casting between classes and structs, my question is if that is extensible to castings to primary types.
What I would like to do is something like:

Code:
typedef struct SC_MsgFrameToRbc

{

  uint32_t idIxl;

  uint32_t size;

  uint8_t frame[MAX_SIZE_FRAME];

} SC_MsgFrameToRbc;

SC_MsgFrameToRbc *msgReceived = NULL;

SC_MsgFrameToRbc msgSended = NULL;

char *buffer = NULL;

msgSended.idIxl = 1;

msgSended.size = 2

...

// Simulates sending message

memcpy(buffer, reinterpret_cast(&msgSended), sizeof(SC_MsgFrameToRbc)); // Compliant ??

// Message reception

msgReceived = reinterpret_cast(buffer); // Compliant ??

where the memcpy simulates other system-dependent code that implements message sending, would the two castings be compliant?

Relational operators and plain chars and wchar_t

Fri, 26 Mar 2010 15:41:01 +0000

The documentation for MISRA C++ rule #4-5-3 includes the following:

Quote:The relational operators = may be used to determine if a character (or wide character) represents a digit.

The document then includes several examples which demonstrate compliance (or lack thereof) for the '>=' and '