将灵活数组更改为指针

Question

I am working to get rid of MISRA violations coming in my C code. It is violating rule 18.7 .

struct abc {
  struct header;
  uint8_t data[]; /* Line 1 */
};

Here, Line 1 is causing the MISRA violations.

I tried to convert it into:

struct abc {
  struct header;
  uint8_t *data;
};

Can we do like the above or is it violating something ?

Answer 1

Your solution is semantically different and won't work even if it clears the violation.

The intent here is to create a structure that can act as a header for the contiguous data that follows it. So for example if you have:

struct Message
{
    struct abc info ;
    char data[128] ;
}  message ;

Such that message.info.data and message.data refer to the same thing and casting a struct abc to a struct Message allows a function to be defined for passing any object with a struct abc header. Effectively supporting polymorphism in C.

Replacing it with:

struct abc 
{
  struct header;
  uint8_t* data;
};

is semantically different because the data member does not refer to the data contiguous with header . The copy semantics also differ, and it is unlikely in the context of the code that uses the original structure that it will work as intended.

GCC supports the following syntax:

struct abc 
{
  struct header;
  uint8_t data[0] ;
} ;

but it is likely that is not MISRA compliant either. A compliant solution is to have:

struct abc 
{
  struct header;
  uint8_t data[1] ;
} ;

But that inserts an extra character and any code that uses this as a header may need to accommodate that when accessing the data through the data member.

Answer 2

All safety-related systems bans dynamic memory allocation, and therefore MISRA-C:2012 does so as well. This is the rationale for rule 18.7: flexible array members are closely associated with with dynamic allocation and therefore not allowed.

The reason why dynamic allocation is banned is that there can be no non-deterministic behavior in these kind of systems. In addition, it doesn't make any sense to use dynamic allocation in microcontroller/RTOS applications.

You can swap the flexible array member for a pointer if it makes sense to your application. But if it is some manner of protocol or data structure header, you probably want a fixed-size array instead. (And mind struct padding: storing data communication protocols in structs can be problematic because of alignment and endianess.)

Answer 3

Yes you can, as it makes the structure size deterministic and static, but it also forces you to allocate then release the needed space for data with malloc() and free() , or explicitly make it point to some already available space somewhere, each time you instanciate the structure.

What you probably want to do here is to specify a definite length to your array. If however this structure is meant to actually describe the header of a data block, you may use data[1] then let your index exceed this value to access the rest (ISO C forbids 0-length arrays, though).