MISRA C:2012 8 Rules 8.1 A Standard C environment

8.1 

程序不得违反标准C语法和约束，不得超出实现的转换限制

0232  十六进制转义序列的值在“unsigned char”类型中无法表示。

int ia = '\x4142';                    /* Message 0232 */

char 字符常量只有1个Byte大小（不考虑宽字符常量），‘\x4142’ = 16706, 超过范围了。 0-255

十六进制转义序列的值不得超过unsigned char中可表示的值的范围.

char 类型用于存储字母和标点符号之类的字符，但是在技术实现上char却是整数类型，这是因为char类型实际存储的是整数而不是字符

char grade  = 'A' ;

char grade = 65; // 这是一种不好的编程风格

令人奇怪的是，C将字符常量视为int类型而非char类型

 0233 八进制转义序列的值不得超过unsigned char中可表示的值的范围

/*PRQA S 3123,3211,3408,3610,3625,3628 ++*/

int ia = '\432';                    /* Message 0233 */

0322 'for'语句声明中使用的非法存储类说明符

for循环的第一项可以声明变量，但是只有'auto' and 'register'两个存储类说明符可以用， 'static', 'extern' or 'typedef'不可用

void foo(void)
{
    for (static int i = 0; i < 10; ++i)    /* Message 0322 */
    {
    }
}

https://blog.csdn.net/wfreehorse/article/details/60762579

 0338 八进制和16进制转义字符值超过‘unsigned char’ ‘wchar_t’所表示的范围

char *s = "\400";                    /* Message 0338 */
// \400 = 256  ; \377 = 255 
// "\400" 是一个字符数组，s[0] = '\400' , s[1] = '\0'

0422 调用函数是传参的个数 小于 函数原型指定的参数个数

int foo(int a, int b);

void test(int x)
{
    int ret;

    ret = foo(x);              /* Message 0422 */
}

0423 调用函数是传参的个数 大于 函数原型指定的参数个数

0426 被调用函数返回类型不完整

typedef struct S T1;

extern T1 s;
extern T1 foo1(int n);

void foo2(int n)
{ /* struct S 还没定义 */
    s = foo1(n);                /* Message 0426                     */
}

struct S {int a; int b;};       /* struct S is now a complete type  */

void foo3(int n)
{
    s = foo1(n);                /* OK - return type is now complete */
}

0427 该对象已被用作函数或函数指针标识符。

void foo(void)
{
    int r;
    int name;

    r = name();                 /* Message 0427 */
}

0429 一个函数的参数是算术类型，但是传进去的参数不是算术类型。

extern void foo(int p);

struct ST1 { int si; char sbuf[10];};
union  UN1 { int ui; int uj;};

extern struct ST1 st1a;
extern union  UN1 un1a;

extern int *pi;
extern int gi;


extern void test(void)
{
    foo(gi);                  /* OK           */
    foo(pi);                  /* Message 0429 */
    foo(&gi);                 /* Message 0429 */
    foo(st1a);                /* Message 0429 */
    foo(un1a);                /* Message 0429 */
}

0430 跟上一条类似，函数传参类型不匹配。

0431 函数参数指向受限类型（Function argument points to a more heavily qualified type）。

不能把const type *  传给函数参数原型为  type*  

不能把volatile type *  传给函数参数原型为  type*  

反之可以，可以把 type *  传给函数参数原型为 const  type*  

eg:

const int *a;

int *b;

b = a; // wrong

a = b; // right 指针a指向的内容不能变（不能通过指针a改变，可以通过其他指针改变），但是指针a这个地址可以变。

#include

int main()
{
    const int a[3] = { 1 , 2,3 };
    const int *c = a;
    int b[3] = { 4,5,6 };
    //a = b;
    c = b;
    //c[1] = 3; // wrong
    //b = c;// wrong
    printf("%d\n", c[1]);
}

 

extern void fi(int * pi);
extern void fci(const int * pci);
extern void fvi(volatile int * pvi);
extern void fcvi(const volatile int * pcvi);

extern int *pi;
extern const int *pci;
extern volatile int *pvi;
extern const volatile int *pcvi;


void test(void)
{
    fi(pi);                   /*              */
    fi(pci);                  /* Message 0431 */
    fi(pvi);                  /* Message 0431 */
    fi(pcvi);                 /* Message 0431 */

    fci(pi);                  /*              */
    fci(pci);                 /*              */
    fci(pvi);                 /* Message 0431 */
    fci(pcvi);                /* Message 0431 */

    fvi(pi);                  /*              */
    fvi(pci);                 /* Message 0431 */
    fvi(pvi);                 /*              */
    fvi(pcvi);                /* Message 0431 */

    fcvi(pi);                 /*              */
    fcvi(pci);                /*              */
    fcvi(pvi);                /*              */
    fcvi(pcvi);               /*              */
}

 0432 函数参数不是兼容的指针类型

struct ST1 { int si; char sbuf[10];};
union  UN1 { int ui; int uj;};

extern struct ST1 st1a;
extern union  UN1 un1a;

extern char *pc;
extern char **ppc;
extern char gc;
extern char cbuf[10];
extern unsigned char *puc;

extern void foo(char * ptp);

void test(void)
{
    foo(pc);                  /* OK           */
    foo(st1a);                /* Message 0432 */
    foo(un1a);                /* Message 0432 */
    foo(gc);                  /* Message 0432 */
    foo(ppc);                 /* Message 0432 */
    foo(cbuf);                /* OK           */
    foo(puc);   /* Message 0432   'char' and 'unsigned char' (or 'signed char') are distinct types*/
}

0446 ++ / -- 操作数必须是标量

struct ST  {int a; int b;};
union  UN  {char c[4]; int x;};

extern struct ST st;
extern union  UN un;

void foo(void)
{
    st++;                       /* Message 0446 */
    un++;                       /* Message 0446 */
}

0447 ++ /  -- 的操作数必须是可修改的对象。

extern        int x[10];
extern const  int y;

void foo(void)
{
    ++x;                        /* Message 0447 */
    ++y;                        /* Message 0447 */
}

0448 ++ /  -- 的操作数不能是指向未知大小的对象的指针。

extern struct TAG *pc;
extern int (*pa)[];
extern void       *pv;

void foo (void)
{
    ++pc;               /* Message 0448 */
    ++pv;               /* Message 0448 */
    ++pa;               /* Message 0448 */
}

0449 ++ /  -- 的操作数不能是函数指针

extern void (*fn_ptr)(void);

void foo (void)
{
   ++fn_ptr;                  /* Message 0449 */
}

0450 数组类型表达式不能 类型转换

类型转换的操作数必须是标量类型（scalar type）  (A basic type, enumeration type or pointer type)

(The type char, the signed and unsigned integer types, and the floating types)

struct ST { int ai[3]; };

extern struct ST sf(void);
extern struct ST sta;
extern int       ibuf[10];

void foo(void)
{
    char *pc;

    pc = (char *)ibuf;              /* OK - ibuf decays to type pointer to int      */
    pc = (char *)(sta.ai);          /* OK - sta.ai decays to type pointer to int    */
    pc = (char *)(sf().ai);         /* Message 0450 and also 0481                   */
    pc = (char *)sta;               /* Message 0481 - sta is not of scalar type     */
}

0452 指针下标索引未知大小的对象。

extern struct ST *gx;           /* The size of struct ST is unknown */

void foo(struct ST *px)
{
   *gx = px[2];                 /* Message 0452 */
}

0454  取地址符& 不能应用于 使用'register'声明的对象

void foo (void)
{
    register int a;
    int *pa;

    pa = &a;               /* Message 0454 */
}

The address-of operator '&' cannot be applied to an object declared with the 'register' storage-class specifier.

The C language defines five storage-class specifiers: static, extern, auto, register and typedef

0456 该表达式没有地址 - “＆”只能应用于左值或函数指示符。

运算符＆只能应用于函数指示符或左值，不能指定 位字段 且不能 指定 寄存器存储类说明符 声明的对象。

extern int g;
extern void func(int x);

void foo(void)
{
    int *pi;
    void (*pvf)(int x);

    pi = &g;           /* Operand of & is an lvalue              */
    pvf = &func;       /* Operand of & is a function designator  */
    pvf = func;        /* & is optional on a function designator */ /* See ISO-C90 6.2.2.1 */

    pi = &(g + 1);     /* Message 0456                           */
}

0457 取地址符不能应用在位字段

位bit 可以占据 一个字节byte中的部分或者全部， & 根据字节读地址，不能精确到字节中某一位的地址。

struct flags {
   unsigned int hi:1;
   unsigned int lo:1;
   unsigned int ins:1;
   unsigned int ovr:1;
};

int main(void)
{
   struct flags f;
   int *ip;
   unsigned int i;

   f.hi = 0;
   f.lo = 0;
   f.ins = 0;
   f.ovr = 0;


   ip = &(f.hi);           /* Message 0457 */
   ip = &f.lo;             /* Message 0457 */

   i = f.ins;

   return 0;
}

https://blog.csdn.net/huasir_hit/article/details/75201126

有些信息在存储时，并不需要占用一个完整的字节， 而只需占几个或一个二进制位。例如在存放一个开关量时，只有0和1 两种状态， 用一位二进位即可。为了节省存储空间，并使处理简便，C语言又提供了一种数据结构，称为“位域”或“位段”。所谓“位域”是把一个字节中的二进位划分为几个不同的区域，并说明每个区域的位数。每个域有一个域名，允许在程序中按域名进行操作。 这样就可以把几 
个不同的对象用一个字节的二进制位域来表示。 

一、位域的定义和位域变量的说明位域定义与结构定义相仿，其形式为： 
　　struct 位域结构名 
　　{ 位域列表 }; 
　　其中位域列表的形式为： 类型说明符 位域名：位域长度 

 https://www.runoob.com/cprogramming/c-bit-fields.html.

#include 
#include <string.h>
 
/* 定义简单的结构 */
struct
{
  unsigned int widthValidated;
  unsigned int heightValidated;
} status1;
 
/* 定义位域结构 */
struct
{
  unsigned int widthValidated : 1;
  unsigned int heightValidated : 1;
} status2;
 
int main( )
{
   printf( "Memory size occupied by status1 : %d\n", sizeof(status1));
   printf( "Memory size occupied by status2 : %d\n", sizeof(status2));
 
   return 0;
}

/*当上面的代码被编译和执行时，它会产生下列结果：*/
Memory size occupied by status1 : 8
Memory size occupied by status2 : 4

/* 位域声明
在结构内声明位域的形式如下：
*/
struct
{
  type [member_name] : width ;
};
0457 取地址符不能应用在位字段

0482 Expressions may only be cast to 'void' or scalar types.

typedef struct ST { int a; } T;
typedef void (FUNC)(void);

int bar(void);

void foo(int n)
{
    T  t;

    t = (T)n;         /* Message 0482 - attempting to cast to struct type   */
    (FUNC)n;          /* Message 0482 - attempting to cast to function type */
    (void)bar();      /* OK                                                 */
}

0483 指向未知大小的对象的指针不能是加法运算符的操作数。

当进行任何一种指针的算术运算时，必须要知道指针指向对象的大小，例如，指针 加1，指针的值不是增加1，增加的是指向对象类型的大小。

extern struct ST *ps;
extern void *pv;

void foo(int n)
{
   ps = ps + n;       /* Message 483 */
   pv = pv + n;       /* Message 483 */
}

0546 枚举类型定义不完整

enum ETAG ex;                       /* Message 0546 */

void foo(void)
{
}

 

转载于:https://www.cnblogs.com/focus-z/p/11456302.html