Exponenta Banner
exponenta event banner

MISRA C:2012 Правило 10.1

Операнды не должны быть неподходящего существенного типа

развернуть все на странице

Описание

Определение правила

Операнды не должны быть неподходящего существенного типа.

Объяснение

Что такое основные типы?

Категория существенного типа определяет существенный тип объекта или выражения.

Категория основного типаСтандартные типы

По существу булево

bool или _Bool (определено в stdbool.h)

С помощью опции можно также определить типы, которые по существу являются логическими. Effective boolean types (-boolean-types).

По существу характер

char

По существу перечисление

названный enum

По существу подписано

подписанный char, подпись short, подпись int, подпись long, подпись long long

По существу без подписи

неподписанный char, без подписи short, без подписи int, без подписи long, без подписи long long

По существу плавающий

float, double, long double

Усиление и обоснование

Для операндов некоторых операторов нельзя использовать некоторые важные типы. В таблице ниже каждая строка представляет комбинацию оператор/операнд. Если столбец основного типа не пуст для этой строки, при использовании этого типа в качестве операнда действует ограничение MISRA. Число в таблице соответствует списку обоснований после таблицы.

ОперацияКатегория существенного типа арифметического операнда
ОператорОперандБулевхарактерenumподписанныйнеподписанныйплавание
[ ]целое число34   1
+ (унарный) 345   
- (унарный) 345 8 
+ -также3 5   
* /также345   
%также345  1
< > <= >=также3     
== !=также      
! && ||любой 22222
<< >>левый345,66 1
<< >>правильно3477 1
~ & | ^любой345,66 1
?:1-й 22222
?:2-е и 3-е      

  1. Выражение по существу плавающего типа для этих операндов является нарушением ограничения.

  2. Если операнд интерпретируется как логическое значение, используйте выражение по существу логического типа.

  3. Если операнд интерпретируется как числовое значение, не используйте операнд по существу логического типа.

  4. Если операнд интерпретируется как числовое значение, не используйте операнд по существу символьного типа. Числовые значения символьных данных определяются реализацией.

  5. В арифметической операции не используйте операнд по существу перечислительного типа. Объект перечисления использует целочисленный тип, определенный реализацией. Поэтому операция, включающая объект перечисления, может дать результат с неожиданным типом.

  6. Выполнять только сдвиговые и побитовые операции с операндами по существу неподписанного типа. При использовании операций сдвига и побитового преобразования для по существу подписанных типов результирующее числовое значение определяется реализацией.

  7. Чтобы избежать неопределенного поведения при отрицательных сдвигах, используйте по существу беззнаковый операнд правой руки.

  8. Для унарного оператора минус не используйте операнд по существу неподписанного типа. Реализованный размер int определяет достоверность результата.

Следует отметить, что для типа битового поля, если битовое поле реализовано следующим образом:

  • Логическое, битовое поле по существу является логическим.

  • Подписанный или неподписанный тип, битовое поле является по существу подписанным или неподписанным соответственно.

    Тип битового поля является наименьшим типом, который может представлять битовое поле. Например, тип stmp здесь по существу 8 бит целое:

    typedef signed int mybitfield;
typedef struct { mybitfield f1 : 1; } stmp;

Дополнительное сообщение в отчете

operand_name операнд operator_name оператор относится к неподходящей категории существенного типа category_name.

Поиск неисправностей

Если вы ожидаете нарушения правила, но не видите его, обратитесь к разделу Нарушения стандартов кодирования не отображаются.

Примеры

развернуть все

#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).

#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).

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 нарушается, поскольку операторы & и << не ожидайте по существу операндов символов. Однако, по меньшей мере, один из используемых здесь операндов имеет по существу символьный тип.

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 нарушается, поскольку арифметические операторы --, * и += не ожидайте по существу перечисляемых операндов. Однако, по меньшей мере, один из используемых здесь операндов имеет по существу перечислительный тип.

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 нарушено, поскольку & и << операции не должны выполняться над по существу подписанными операндами. Однако используемые здесь операнды подписаны.

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, поскольку операция << не ожидает по существу подписанного правильного операнда. Однако используемые здесь правильные операнды подписаны.

Проверить информацию

Группа: Модель основного типа
Категория: Обязательно
СМЖЛ Категория: Консультативные услуги

См. также

|

Темы

Документация для поиска ошибок Polyspace

Поддержка