MISRA Discussion Forums - 6.0 Language independent issues (C++)

Rule 0.1.9 - is zero-initialization considered "dead code"?

Wed, 25 Sep 2024 07:22:15 +0000

Consider the following example:

Code:
// third_party.h

struct Foo

{

   int32_t a;

   int32_t b;

};

// client.cpp

Foo create()

{ 

  Foo f{};     // Violates Rule 0.1.9?

  f.a = 123;

  f.b = 321;

  return f;

}

Does that violate Rule 0.1.9? While the initialization may be redundant, it serves a purpose as defensive programming. If we remove the zero-initialization, we risk having some members of "Foo" uninitialized, especially if we bump to a new version of "third_party.h" that adds a new member to the struct. It's safer to zero-initialize at the declaration, to ensure no members remain uninitialized.

It's also preferable to initialize like this instead of "Foo f{123, 321};", because we can see written in code which field gets which value. We need to wait until C++20 to get designated initializers in C++ to initialize everything in one line.

Thanks!

Rule 0-1-11 and postfix increment/decrement operators

Thu, 19 Nov 2020 16:29:23 +0000

Rule 0-1-11 states that there shall be no unused parameters (named or unnamed) in a non-virtual function.

However, when writing a postfix increment/decrement operator, the C++ standard states:

Quote:If the function is a member function with one parameter (which shall be of type int) or a non-member function with two parameters (the second of which shall be of type int), it defines the postfix increment operator ++ for objects of that type.
...
The prefix and postfix decrement operators -- are handled analogously.

Such operators are then written as:

Code:
struct X {

  X operator++(int); // postfix a++

};

On the face of it, this seems to violate Rule 0-1-11, because the unnamed int parameter is unused.

Is this an real violation, so that in order to write postfix increment/decrement operators we have to deviate, or is this rule not intended to apply in such cases where the C++ standard itself is defining that the parameter is unused (and therefore any flagging of such code is a false positive)?

I cannot find any direct prohibition of the writing of postfix increment/decrement operators elsewhere in the MISRA rules, so it surprises me that this rule appears to prohibit their use in this roundabout fashion.

Rule 0-1-6 and Boolean variables

Wed, 18 Nov 2020 21:50:41 +0000

Rule 0-1-6 seems to be counter productive with Boolean variables. DU dataflow anomalies are normal and desirable with Boolean variables. For example:

Code:
extern bool random_bool ();

bool non_compliant_and (void)

{

    bool const b1 = random_bool();

    bool const b2 = random_bool();

    return b1 && b2;   // b2 is DU dataflow anomaly when b1 is false

}

bool non_compliant_or (void)

{

    bool const b1 = random_bool();

    bool const b2 = random_bool();

    return b1 || b2;   // b2 is DU dataflow anomaly when b1 is true

}

bool compliant_and (void)

{

    bool const b1 = random_bool();

    bool const b2 = random_bool();

    bool tmp = b1;

    tmp = b2 && b1;

    return tmp;

}

bool compliant_or (void)

{

    bool const b1 = random_bool();

    bool const b2 = random_bool();

    bool tmp = b1;

    tmp = b2 || b1;

    return tmp;

}

The compliant and non-compliant code result in different binaries. Both seem equally safe, but the compliant solution is less efficient. Which seems at odds with the statement in MISRA spec claims

Quote:At best this (DU dataflow anomaly) is inefficient, but may indicate a genuine problem.

Is there any insight anyone can provide on such a perplexing problem?

Rule 0-1-6 Variables being given values that are never used.

Fri, 17 Jan 2020 17:34:18 +0000

The actual rule is:

Quote:A project shall not contain instances of non-volatile variables being given values that are never subsequently used.

There has been a lot of discussion as to what that sentence actually means. One camp believes that this rule applies to DU dataflow anomalies only, and the other believes that it applies to DU and DD dataflow anomalies.

For example the following code contains a DD dataflow anomaly, but not a DU dataflow anomaly. Is it a Rule 0-1-6 violation?

Code:
int32_t foobar (int32_t const value)

{

    int32_t returnValue = value;

    if (value < 0)

    {

        returnValue = 0;

    }

    return returnValue;

}

This debate is influencing discussions on the merits of variable initialization.

Rule 0-1-7 Exception clarification

Sun, 01 Sep 2019 13:36:41 +0000

Hi,

I have 3 questions:
1. Why in the exception for the rule, a C-style cast was used (like in case #1 below), instead of functional notation cast (like in case #2 below)?
2. Does using a functional notation cast violates this rule?
3. Is it legit to do the cast through a typedef as shown in case 3 (or 4 in case that functional notation cast is allowed for that purpose)?

Thanks,
Udi.
==== Below are the referenced code examples ===
namespace SE
{
typedef void UnusedRetVal;
}

1. (void)std:trtol(pszValue, &pszEndPtr, 10); // copmliant
2. void(std:trtol(pszValue, &pszEndPtr, 10)); // not compliant ?
3. (SE::UnusedRetVal)std:trtol(pszValue, &pszEndPtr, 10); // not compliant ?
4. SE::UnusedRetVal(std:trtol(pszValue, &pszEndPtr, 10)); // not compliant ?

Rule 0-1-3/0-1-4/0-1-5 and (template) class members

Wed, 01 Feb 2017 18:11:35 +0000

Do these rules apply to class members?

If so, do they apply to instances of template class members?

Code:
template

class C {

    T member1; // never used; compliant with 0-1-3?

    T member2; // C::member2 is used but C::member2 is not; compliant with 0-1-3?

    typedef T Unused; // typedef never used: non-compliant with 0-1-5.

    typedef T X; // C::X is used but C::X is not; compliant with 0-1-5?

    void call() { // only instantiated for C

       use(static_cast(member2));

    }

};

int main() {

  C().call();

  C();

}

The same question also applies to 0-1-4.

For 0-1-10 the situation is different, as class template member functions only get instantiated if they actually used. Thus C::call() is compliant with 0-1-10. A completely unused class template member function would be non-compliant with Rule 14-7-1.

Proposal: Rule 0-1-4 exception

Thu, 27 Oct 2016 11:16:35 +0000

Exception: Variables which are written by the program but read by an external entity (e.g. ASAM MCD tools like Vector CANape) are not considered a violation of this rule.

Proposal: Rule 0-1-3 exception

Thu, 27 Oct 2016 11:09:00 +0000

Dear MISRA team,

we have certain variables which are required by our boot loader (a separate binary) but are not used in the main program itself.
In my book, this is not a violation of 0-1-3, because clearly those variables have a usage, albeit one that static analysis cannot prove.
Therefore i would like to propose the following addendum to rule 0-1-3:

Exception: a variable which is required by an external binary program only (e.g. an embedded systems boot loader) is not considered a violation of this rule.

Rule 0-1-9

Wed, 28 Sep 2016 12:52:24 +0000

Please add an explicit exception for static_assert if the next MISRA C++ version allows C++11.
Thanks.

0-1-2 Infeasible paths clarification

Thu, 06 Mar 2014 10:56:41 +0000

I have a pure virtual function like
virtual void OnEvent(EventName event, State& superState) = 0;

For some of the derived classes, the implementation uses both of the the parameters. For others, the parameters are not used at all.

Is this acceptable?

0-1-8. Exception: empty interface function.

Mon, 18 Nov 2013 13:55:49 +0000

0-1-8:
The following are examples of external side effects:
â€¢ Reading or writing to a ile, stream, etc.;
â€¢ Changing the value of a non local variable;
â€¢ Changing the value of an argument having reference type;
â€¢ Using a volatile object;
â€¢ Raising an exception.

Situation:
There is some mouse interface: OnMouseUp, OnMouseDone, OnMouseMove... or some other manipulator interface... does not matter...
There are some objects that use this interface but not all objects need all functions, so it is possible:
void SomeObject::OnMouseMove ( uint32 x, uint32 y)
{
//do nothing
}

Rules 0-1-3, 0-1-4, 0-1-5 and 0-1-8. External libs.

Mon, 18 Nov 2013 13:17:11 +0000

Rules 0-1-3, 0-1-4, 0-1-5 and 0-1-8 could have exception as using external libs.
The could be include external lib header or involved lib external sources that have more functionality than uses the project.

Yes?

0-1-8 and OO design pattern

Tue, 02 Oct 2012 06:03:23 +0000

0-1-8 restricts such elegant design pattern as e. g. observer/listener (with selective handling of a subset of notifications by observer).
So is the "intended" use of empty virtual methods due to design OK? May design goals be classified as "side effect"?

Just to be clear on 0-1-8 ...

Fri, 19 Nov 2010 18:56:03 +0000

The standard library implementation here has the body of one of the standard library functions defined as, literally, "{ }". The function does not do anything except go, "Yes, I have been called." Did MISRA intend to prohibit such a definition with respect to 0-1-8?

Notion of unused parameter in 0-1-11 and 0-1-12

Sun, 25 Jul 2010 14:58:42 +0000

Suppose `a' is a parameter. Does `sizeof(a)' count as a use of `a' for the purpose of compliance to 0-1-11 and 0-1-12?