MISRA C:2012 Rule 10.1

Operands shall not be of an inappropriate essential type

描述

规则定义

Operands shall not be of an inappropriate essential type ¹ .

理由

什么是基本类型？

基本类型分类定义了对象或表达式的基本类型。

基本类型分类	标准类型
本质上为布尔类型	`bool` 或 `_Bool`（在 `stdbool.h` 中定义）您还可以使用`有效布尔类型 (-boolean-types)` 选项定义本质上为布尔的类型。
本质上为字符类型	`char`
本质上为枚举类型	named `enum`
本质上为有符号类型	signed `char`, signed `short`, signed `int`, signed `long`, signed `long long`
本质上为无符号类型	unsigned `char`, unsigned `short`, unsigned `int`, unsigned `long`, unsigned `long long`
本质上为浮点类型	实数浮点：`float`, `double`, `long double` 复数浮点：`float _Complex`, `doble _Complex`, `long double _Complex`

补充说明及理由

对于某些运算符的操作数，您无法使用特定的基本类型。在下表中，每一行代表一个运算符/操作数的组合。如果该行中的“基本类型”列不为空，则表示在将该类型用作操作数时将受 MISRA 规则的限制。表中的数字对应表后面的理由列表。

操作		算术操作数的基本类型分类
运算符	操作数	布尔	字符	枚举	signed	无符号	浮点
运算符	操作数	布尔	字符	枚举	signed	无符号	实数	复数
`[ ]`	整数	3	4				1	9
`+`（一元）		3	4	5
`-`（一元）		3	4	5		8
`+ -`	任一	3		5
`++ --`		3		5				9
`* /`	任一	3	4	5
`%`	任一	3	4	5			1	9
`< > <= >=`	任一	3						9
`== !=`	任一						10	10
`! && \|\|`	任意		2	2	2	2	2	2
`<< >>`	左	3	4	5、6	6		1	9
`<< >>`	右	3	4	7	7		1	9
`~ & \| ^`	任意	3	4	5、6	6		1	9
`?:`	第一个		2	2	2	2	2	2
`?:`	第二个和第三个

这些操作数的表达式本质上为浮点类型，这违反了约束。
当一个操作数被解释为布尔值时，请使用本质上为布尔类型的表达式。
当一个操作数被解释为数字值时，不要使用本质上为布尔类型的操作数。
当一个操作数被解释为数字值时，不要使用本质上为字符类型的操作数。字符数据的数值由实现定义。
在算术运算中，不要使用本质上为枚举类型的操作数。枚举对象使用实现定义的整数类型。因此，涉及枚举对象的运算可能会产生类型出乎意料的结果。
仅对本质上为无符号类型的操作数执行移位和位运算。当对本质上为有符号的类型使用移位和位运算时，结果的数值是未定义的或由实现定义的。
为了避免负位移操作导致的未定义行为，请使用本质上为无符号的右操作数。
对于一元减运算符，不要使用本质上为无符号类型的操作数。int 类型的实际实现大小决定了结果的符号性。
这些操作数的本质上为复数浮点类型的表达式违反了约束。
比较浮点类型可能会导致意外且与实现相关的结果。比较浮点类型时，请考虑浮点精度 (FLT_EPSILON) 和数字的大小。

请注意，对于位字段类型，如果位字段实现为：

布尔值，位字段基本上为布尔值。
有符号或无符号类型，位字段本质上分别为有符号或无符号的。
位字段的类型是能够表示位字段的最小类型。例如，这里的类型 stmp 本质上是一个 8 位整数：
```
typedef signed int mybitfield;
typedef struct { mybitfield f1 : 1; } stmp;
```

有关基本类型的详细信息，请参阅Essential Types in MISRA C Rules 10.x。

Polyspace 实现

当运算的操作数为不适当的基本类型时，Polyspace^® 会报告违反此规则。作为例外，Polyspace 不会报告以下使用情况下的违规行为：

使用一个本质上为有符号类型的非负整数常量表达式作为移位运算符的右操作数。
将本质上为实数的浮点或基本为复数浮点的对象与常量零或宏 INFINITY 或 -INFINITY 进行比较。

故障排除

如果您预期会出现违规，但未看到该违规，请参阅诊断为何编码规范违规未按预期显示。

示例

全部展开

违反规则 10.1，理由 2：运算符的操作数类型不合适（适用于接受本质上为布尔值的操作数）

#include<stdbool.h>
extern float f32a;
extern char cha; 
extern signed char s8a;
extern unsigned char u8a,u8b,ru8a;
enum enuma { a1, a2, a3 } ena, enb; 	
extern bool bla, blb, rbla; 
void foo(void) {

	rbla = cha && bla;        /* Non-compliant: cha is essentially char  */
	enb = ena ? a1 : a2;      /* Non-compliant: ena is essentially enum  */
	rbla = s8a && bla;        /* Non-compliant: s8a is essentially signed char  */
	ena = u8a ? a1 : a2;      /* Non-compliant: u8a is essentially unsigned char  */
	rbla = f32a && bla;       /* Non-compliant: f32a is essentially float */
	rbla = bla && blb;        /* Compliant */
	ru8a = bla ? u8a : u8b;   /* Compliant */
}

在不合规的示例中，规则 10.1 被违反，原因如下：

操作符 && 仅接受本质上为布尔型的操作数。然而，至少有一个操作数使用的类型不同。
?: 的第一个操作数期望本质上为布尔类型的值。然而，这里使用了不同的操作数类型。

注意

要使 Polyspace 检测到规则违规，您必须将类型名称 boolean 定义为有效的布尔类型。有关详细信息，请参阅Effective boolean types (-boolean-types)。

违反规则 10.1，理由 3：不适当的布尔运算符

#include<stdbool.h>
enum enuma { a1, a2, a3 } ena; 
enum { K1 = 1, K2 = 2 };    /* Essentially signed */
extern char cha, chb; 
extern bool bla, blb, rbla; 
extern signed char rs8a, s8a;
extern unsigned char u8a;

void foo(void) {

  rbla = bla * blb;      /* Non-compliant - Boolean used as a numeric value */
  rbla = bla > blb;      /* Non-compliant - Boolean used as a numeric value */

  rbla = bla && blb;     /* Compliant */
  rbla = cha > chb;      /* Compliant */
  rbla = ena > a1;       /* Compliant */ 
  rbla = u8a > 0U;       /* Compliant */
  rs8a = K1 * s8a;       /* Compliant - K1 obtained from anonymous enum */

}

在不合规的示例中，违反了规则 10.1，因为运算符 * 和 > 不期望本质上为布尔类型的操作数。然而，这里使用的操作数本质上为布尔值。

注意

要使 Polyspace 检测到规则违规，您必须将类型名称 boolean 定义为有效的布尔类型。有关详细信息，请参阅Effective boolean types (-boolean-types)。

违反规则 10.1，理由 4：不适当的字符操作数

extern char rcha, cha, chb; 
extern unsigned char ru8a, u8a;

void foo(void) {

  rcha = cha & chb;      /* Non-compliant - char type used as a numeric value */
  rcha = cha << 1;       /* Non-compliant - char type used as a numeric value */

  ru8a = u8a & 2U;       /* Compliant */	
  ru8a = u8a << 2U;      /* Compliant */
 
}

在不合规的示例中，违反了规则 10.1，因为运算符 & 和 << 不期望本质上为字符类型的操作数。但是，这里使用的至少一个操作数本质上为字符类型。

违反规则 10.1，理由 5：不适当的枚举操作数

typedef unsigned char boolean;

enum enuma { a1, a2, a3 } rena, ena, enb; 

void foo(void) {

  ena--;             /* Non-Compliant - arithmetic operation with enum type*/
  rena = ena * a1;   /* Non-Compliant - arithmetic operation with enum type*/
  ena += a1;         /* Non-Compliant - arithmetic operation with enum type*/

}

在不合规的示例中，规则 10.1 被违反，因为算术运算符 --、* 和 += 不期望本质上为枚举类型的操作数。然而，这里使用的至少一个操作数本质上为枚举类型。

违反规则 10.1，理由 6：位运算中运算数类型不匹配

extern signed char s8a;
extern unsigned char ru8a, u8a;

void foo(void) {

  ru8a = s8a & 2;       /* Non-compliant - bitwise operation on signed type */
  ru8a = 2 << 3U;       /* Non-compliant - shift operation on signed type */
	
  ru8a = u8a << 2U;     /* Compliant */	

}

在不合规的示例中，违反了规则 10.1，因为不能对本质上为有符号的操作数执行 & 和 << 运算。然而，这里使用的操作数是有符号的。

违反规则 10.1，理由 7：移位运算中右操作数签名不正确

extern signed char s8a;
extern unsigned char ru8a, u8a;

void foo(void) {

  ru8a = u8a << s8a;    /* Non-compliant - shift magnitude uses signed type */	
  ru8a = u8a << -1;     /* Non-compliant - shift magnitude uses signed type */	

  ru8a = u8a << 2U;     /* Compliant */	
  ru8a = u8a << 1;      /* Compliant - exception */	

}

在不合规的示例中，违反了规则 10.1，因为运算 << 不期望一个本质上为有符号类型的右操作数。然而，这里使用的正确操作数是有符号的。

违反规则 10.1，理由 10：`==` 和 `!=` 操作符不支持浮点数操作数

#include <complex.h>
#include <stdbool.h>
#include <math.h>
_Complex float cnx, cny;
float fx;
void amd3() {

      cnx ? 1 : 0;                    // Noncompliant
      cny = !cnx;                     // Noncompliant
      cny = cnx && cny;               // Noncompliant
      cny = cnx || cny;               // Noncompliant
      if(fx != 0.0f) // Compliant
      {}
      if(cnx != INFINITY) // Compliant
      {}
}

在示例中，Polyspace 报告了违反规则 10.1 的情况，因为本质上为浮点类型的操作数与运算符 == 和 != 一起使用。作为例外情况，使用这些运算符将本质上为浮点类型的操作数与 0.0f 和 INFINITY 进行比较并不违反规则。

检查信息

组：基本类型模型

类别：必需

AGC 类别：建议

版本历史记录

全部展开

R2025a: 值为 1 和 0 的 `true` 和 `false` 宏本质上被视为布尔值

Polyspace 现在将来自 stdbool.h 的宏 true 和 false 本质上视为布尔值。如果指定选项 -boolean-types，则当宏 true/TRUE/True 和 false/FALSE/False 的值分别为 1 和 0 时，它们也本质上被视为布尔值。

R2024a: 报告了使用实数和复数浮点类型进行平等检查时的违规情况

根据 MISRA C:2012 修订版 3，当您使用运算符 == 或 != 来比较本质上为浮点实数或本质上为浮点复数的表达式时，Polyspace 会报告违规。例如，在此代码中，== 和 != 运算违反了此规则：

float f32w = -1.0f;
float f32x = 0.2f;
float f32y = 0.9f;
float f32z = 0.0f;
if((f32w + f32x) == f32y) {} //Violation
if(f32w != f32y) {} //Violation

作为例外，Polyspace 在以下使用情况下不会报告违规行为：

使用一个本质上为有符号类型的非负整数常量表达式作为移位运算符的右操作数。
将本质上为实数浮点或基本为复数浮点的对象与常量 0 或宏 INFINITY 或 -INFINITY 进行比较。例如，在此代码中，== 和 != 运算合规。
```
float flx, fly;
extern _Complex float cnx, cny;
flx != 0.0f; //Not a violation
cnx == -INFINITY; //Not a violation
```

另请参阅

MISRA C:2012 Rule 10.2 | 检查 MISRA C:2012 (-misra3)

主题

The MISRA coding standards referenced in the Polyspace Bug Finder™ documentation are from the following MISRA standards:

MISRA C:2004
MISRA C:2012
MISRA C:2023
MISRA C++:2008
MISRA C++:2023

MISRA and MISRA C are registered trademarks of The MISRA Consortium Limited 2021.