静态分析混合C和C ++代码的奇怪符号行为

Question

Given the following definitions in a mixed C and C++ program:

//in a C file.
uint8_t GetSize()
{
return (uint8_t)something;
}

//in the header of the C++ file.

public:
  MyClass(){};
private:
  uint8_t index_m;

Both of the following lines give me a static tool (pc-lint) warning 573 .

void MyClass::IncrementWithRollOver(void)
{
        index_m = (index_m + 1) % GetSize(); // warning 573 : signed-unsigned mix with divide
}
void MyClass::DecrementWithRollOver(void)
{
        index_m = (GetSize() - 1 + index_m) % GetSize(); // warning 573 : signed-unsigned mix with divide
}

I tried lots of casting but none is helping me getting rid of this warning, why?

        index_m = (index_m + 1U) % GetSize(); // this one works

        index_m = (GetSize() - 1U + index_m) % GetSize();// info 834: operator '-' followed by operator '+' could be confusing without parentheses [MISRA 2004 Rule 12.1, advisory]

        index_m = (uint8_t)(index_m + (uint8_t)1) % GetSize(); // warning 573 : signed-unsigned mix with divide, and: info 732: loss of sign (assignment) ('int' to 'uint8_t' (aka 'unsigned char')

        index_m = (uint8_t)(GetSize() - (uint8_t)1 + index_m) % GetSize(); // warning 573 : signed-unsigned mix with divide, and: info 834: operator '-' followed by operator '+' could be confusing without parentheses [MISRA 2004 Rule 12.1, advisory]

        index_m = (uint8_t)(index_m + (uint16_t)1) % GetSize(); // warning 573 : signed-unsigned mix with divide, and: info 732: loss of sign (assignment) ('int' to 'uint8_t' (aka 'unsigned char')

        index_m = (uint8_t)(GetSize() - (uint16_t)1 + index_m) % GetSize(); // warning 573 : signed-unsigned mix with divide, and: info 834: operator '-' followed by operator '+' could be confusing without parentheses [MISRA 2004 Rule 12.1, advisory]

what a pain in the ... C!

What's the quick fix for this?

---

After reading the comments I also unsuccessfully tried

     index_m = (uint8_t)(index_m + (uint32_t)1) % GetSize(); // works

     index_m = (uint8_t)(GetSize() - (uint32_t)1 + index_m) % GetSize(); // info 834: operator '-' followed by operator '+' could be confusing without parentheses [MISRA 2004 Rule 12.1, advisory]

this get me rid of the sign/unsigned mix problem but this "operator '-' followed by operator '+'" is still weird!

Answer 1

In C/C++, integers that are smaller than an int are promoted to an integer with same sign and as large as an int as soon as you use them in an operation ( + ...).

This is historical and a bit confusing, but I guess the original intent was to limit the risk of overflow on computations with small integers.

In index_m + 1 , index_m will be promoted to unsigned int then the sign mismatch with 1 which is a signed int .

So you will have to cast anyway after the operation is done (depending on warning level).

Answer 2

What's the quick fix for this?

Simplest is:

 index_m = (index_m + 1U) % GetSize(); // this one works

ok for incrementation but the problem is with the decrementation...

 index_m = (GetSize() - 1U + index_m) % GetSize();// info 834: operator '-' followed by operator '+' could be confusing without parentheses [MISRA 2004 Rule 12.1, advisory] 

Note that this is only an info message; not a warning. But regardless, the solution to lack of parentheses is to add parentheses:

index_m = ((GetSize() - 1U) + index_m) % GetSize();

_{Or, apparently change order of operations to (GetSize() + index_m - 1U) , as found out in comments}