Как передать несколько структур в одну функцию (ANSI C)

Question

Я пишу встроенное приложение, предназначенное для работы на частоте 3-7 МГц, поэтому скорость имеет КРИТИЧЕСКОЕ значение.также устройство имеет только 32 КБ ОЗУ. Динамическое выделение памяти НЕ и вариант. Тем не менее ...

Я пишу программу буферизации, которая требует циклические буферы с разной длиной очереди

• 4x 1024+ int (+ означает больше, чем требуется, если доступно)
• 4x 256 int
• 1x 256 int (с другим приложением, чем указанное выше)
• 1x 2048+int (+ означает больше, чем требуется, если доступно)

Я реализовал это в следующем коде.Вы заметите, что я создал 2 буфера в виде массива размера 1, потому что я хочу получить доступ ко всем буферам, используя те же функции ReadBuff и WriteBuff.Моя проблема в том, что когда вы передаете структурный указатель на функцию, компилятор ожидает, что тип данных указателей будет таким же.Передача указателя на тип данных BuffType2 в функцию, которая ожидает BuffType1, однако, несколько недопустима в C и может работать или не работать должным образом, даже если структура структур точно такая же, за исключением размера очереди.Единственный способ решить эту проблему - это динамически распределить размер моей очереди после создания необходимых мне структурных массивов.

Было бы также полезно узнать, что я спроектировал буферы для чтения из хвоста и записи в заголовок, и он спроектирован так, что когда индексы заголовка и хвоста превышают размер буфера, он переполняется до0.

Здесь немного кода

/***************************************************************\
    Macro Definitions
\***************************************************************/ 
// The following sizes MUST be 2^n
#define BUFF_TYPE_1_SIZE    (0h400) /*  1024    */
#define BUFF_TYPE_2_SIZE    (0h100) /*  256 */
#define BUFF_TYPE_3_SIZE    (0h100) /*  256 */
#define BUFF_TYPE_4_SIZE    (0h800) /*  2048    */

#define BUFF_TYPE_1_Q_MASK  (BUFF_TYPE_1_SIZE-0h1)  /* all ones */
#define BUFF_TYPE_2_Q_MASK  (BUFF_TYPE_2_SIZE-0h1)  /* all ones */
#define BUFF_TYPE_3_Q_MASK  (BUFF_TYPE_3_SIZE-0h1)  /* all ones */
#define BUFF_TYPE_4_Q_MASK  (BUFF_TYPE_4_SIZE-0h1)  /* all ones */

//  Error Codes
#define ERROR_BUFF_EMPTY    (-1)    /*  The buffer is empty */
#define ERROR_BUFF_DNE      (-2)    /*  The buffer does not exist   */

//  Test for Buffer Empty
#define BUFF_EMPTY      (Buffer.Head == Buffer.Tail)

// Test for data in buffer
#define BUFF_NOT_EMPTY  (Buffer.Head != Buffer.Tail)

//  Test for Buffer Full
#define BUFF_FULL (((Buffer.Head + 1) & Buffer.Mask) == Buffer.Tail)

/***************************************************************\
    Structure Definitions
\***************************************************************/ 
// Buffers(queues) - These need to be global to allow use in interrupts
typedef struct BuffType1
    {
    int Head        = 0;
    int Tail        = 0;
    int Mask        = BUFF_TYPE_1_Q_MASK;
    char Full   = false;
    char Empty  = true;
    int Q[BUFF_TYPE_1_SIZE];
    };
typedef struct BuffType2
    {
    int Head        = 0;
    int Tail        = 0;
    int Mask        = BUFF_TYPE_2_Q_MASK;
    char Full   = false;
    char Empty  = true;
    int Q[BUFF_TYPE_2_SIZE];
    };
typedef struct BuffType3
    {
    int Head        = 0;
    int Tail        = 0;
    int Mask        = BUFF_TYPE_3_Q_MASK;
    char Full   = false;
    char Empty  = true;
    int Q[BUFF_TYPE_3_SIZE];
    };
typedef struct BuffType4
    {
    int Head        = 0;
    int Tail        = 0;
    int Mask        = BUFF_TYPE_4_Q_MASK;
    char Full   = false;
    char Empty  = true;
    int Q[BUFF_TYPE_4_SIZE];
    };

/***************************************************************\
    Global Variables
\***************************************************************/ 
// FIFO Ring buffers - These need to be global to allow use in interrupts
struct BuffType1 MyBuff1[4];    
struct BuffType2 MyBuff2[4];    
struct BuffType3 MyBuff3[1];    
struct BuffType4 MyBuff4[1];    

/***************************************************************\
    Functions
\***************************************************************/ 

/*---------------------------------------------------------------
int ReadBuff(struct BuffType1* BufferPtr)
Parameters  :   struct* BufferPtr
                        this is a pointer to the buffer you wish to read
Returns     :   int
                        if empty    - error code
                        if not empty - The value that was popped off the buffer
Description :   This function returns the value at the tail of the
                    buffer or an error if the buffer is empty. The 
                    tail is incremented after the read and overflows
                    automatically
---------------------------------------------------------------*/
int ReadBuff(struct BuffType1* BufferPtr)
    {
    int Value = ERROR_BUFF_EMPTY;   // error
    if(BUFF_EMPTY)
        (*BufferPtr).Empty = true;  // set the empty flag
    else
        {
        (*BufferPtr).Empty = false; // reset the empty flag
        Value = (*BufferPtr).Q[(*BufferPtr).Tail];  //  Read value is at the tail of the buffer
        (*BufferPtr).Tail = ((*BufferPtr).Tail + 1)&((*BufferPtr).Mask) /* increment the tail,
            making sure that if it rolls over its queue size, it rolls over to 0    */
        }
    return Value;
    }

/*---------------------------------------------------------------
int WriteBuff(struct* BufferPtr, int Data)
Parameters  :   struct* BufferPtr
                        The pointer to the buffer you wish to write to
                    int Data
                        The Data you wish to write to the buffer
Returns     :   true    - write was successful
                    false   - the buffer is full and did not write
Description :   This function writes the data to the head of the
                    buffer and returns an error if the buffer is full.
                    if the buffer is full, no data is written. The 
                    head is incremented after the write and overflows
                    automatically
---------------------------------------------------------------*/
char WriteBuff(struct BuffType1* BufferPtr, int Data)
    {
    int Success = false;    // there was an error writing to the buffer
    if (BUFF_FULL) 
        (*BufferPtr).Full = true;   // Indicate buffer is full (next avaliable spot to write is the tail)
    else
        {
        (*BufferPtr).Full = false;
        (*BufferPtr).Q[(*BufferPtr).Head] = Data;
        (*BufferPtr).Head = ((*BufferPtr).Head + 1)&((*BufferPtr).Mask)
        }
    return !((*BufferPtr).Full;);   // Return false if buffer was full and write could not happen
    }

/*---------------------------------------------------------------
void ResetBuff(struct* BufferPtr)
Parameters  :   struct* BufferPtr
                        The pointer to the buffer you wish to write to
Returns     :   nothing
Description :   This function resets the buffer but does not clear
                    anything
---------------------------------------------------------------*/
void ResetBuff(struct BuffType1* BufferPtr)
    {
    (*BufferPtr).Head = (*BufferPtr).Tail = 0;
    (*BufferPtr).Full = false;
    (*BufferPtr).Empty = true;
    (*BufferPtr).Q[0] = 0; //or null if it is defined
    }

/*---------------------------------------------------------------
void NullBuff(struct* BufferPtr)
Parameters  :   struct* BufferPtr
                        The pointer to the buffer you wish to write to
Returns     :   nothing
Description :   This function resets all values in the queue to 0
---------------------------------------------------------------*/
void NullBuff(struct BuffType1* BufferPtr)
    {
    int i;
    for(i=0; i=((*BufferPtr).Mask); i++) // for all values in the buffer
        (*BufferPtr).Q = 0; // clear the value
    }

Answer 1

Вы можете создать структуру для буфера с массивом нулевой / одной длины для Q, а затем объединить его с реальной структурой для буфера, который вы хотите использовать. Тогда вам также понадобится какой-то способ узнать длину, которую вы собираетесь использовать, которую вы можете получить либо из своего типа маски, либо из дополнительного члена структуры.

struct BuffType
{
    int Head;
    int Tail;
    int Mask;
    char Full;
    char Empty;
    int Q[1];
};

struct BuffType1_storage
{
    int Head;
    int Tail;
    int Mask;
    char Full;
    char Empty;
    int Q[BUFF_TYPE_1_SIZE];
};

union BuffType1
{
    struct BuffType b;
    struct BuffType1_storage b1;
}

union BuffType1 MyBuff1[4];

Затем вы можете передать указатель на член объединения BuffType1 или struct BuffType b, и вы знаете, что память за ним существует для определенного типа.

Answer 2

Если оставить в стороне соображения производительности, значения размера памяти на данный момент и сосредоточиться на входном параметре мультиструктурного типа, рассматривали ли вы создание структуры заголовка для описания каждого отдельного буфера с указателем на рассматриваемый буфер?Таким образом, вы будете передавать один тип структуры (метаданные буфера), а затем заставлять функцию обработки самим выяснить, как действовать.

РЕДАКТИРОВАТЬ - так что в качестве иллюстрации вы можете взять BuffTypeXвводит и уплотняет информацию о буфере в метаструктуру следующим образом:

typedef struct buffMetaData
  {
  int Head, Tail, Mask, Full, Empty...
  int *PtrToBuff
  };

Ваши буферы будут определены где-то уместно как прямые массивы, и во время инициализации вам нужно будет инициализировать ваши объекты buffMetaData и указать ихсоответствующее место хранения.

Затем вы реализуете свою функцию обработки, чтобы принять тип buffMetaData, прочитать содержимое и продолжить работу с каждым отдельным буфером по мере необходимости (возможно, на основе маски или любого уникального идентификатора, помеченного как поле buffMetaData).может удержаться).

По общему признанию, такой подход может привести к борову памяти, поскольку все буферы должны быть полностью выделены заранее, и вам также необходимо сохранить ОЗУ для стека, кучи и других переменных.