Make struct Array point to another struct Array

Okay, according to the input I got from you guys, I think it might be the best thing to redesign my application.

So instead of a buffer of bStruct's I might use a buffer of aStruct*. This makes sure my buffer is always up to date. And then if I need to do something with an element of the buffer, I will write a short getter-function which copies the data from that aStruct* into a temporary bStruct and returns it.

Thanks for your responses and comments.

If you want b.data[] array to point to exactly the same values, then you can make data of b a char* and make it point to a's data.

Something like

struct{
uint8_t value;
uint8_t unimportant_stuff;
char* data;
}typedef bStruct;

and

b.data = a.data;

But, keep in mind, this means that b.data is pointing at the same memory location as a.data and hence, changing values of b.data would change values of a.data also.

There is another way of doing this. It is by copying all the values of a.data into b.data. Then, b.data would merely contain the same values as a.data, but it would point to different memory locations.

This can either be done by copying one by one. In a for loop for all the 8 elements.

Or, to use memcpy()

NOTE

Arrays cannot be made to point to another memory locations. As they are non modifiable l-value. If you cannot modify the structs, then you have to use the second method.

What you are asking is not possible when you can not modify the existing struct definitions. But you can still automate the functionality with a bit of OO style programming on your side. All of the following assumes that the data fields in the structs are of same length and contain elements of same size, as in your example.

Basically, you wrap the existing structs with your own container. You can put this in a header file:

/* Forward declaration of the wrapper type */
typedef struct s_wrapperStruct wrapperStruct;
/* Function pointer type for an updater function */
typedef void (*STRUCT_UPDATE_FPTR)(wrapperStruct* w, aStruct* src);
/* Definition of the wrapper type */
struct s_wrapperStruct
{
    STRUCT_UPDATE_FPTR update;
    aStruct* ap;
    bStruct* bp;
};

Then you can can create a factory style module that you use to create your synced struct pairs and avoid exposing your synchronization logic to uninterested parties. Implement a couple of simple functions.

/* The updater function */
static void updateStructs(wrapperStruct* w, aStruct* src)
{
    if ( (w != NULL) && (src != NULL) )
    {
        /* Copy the source data to your aStruct (or just the data field) */
        memcpy(w->ap, src, sizeof(aStruct));
        /* Sync a's data field to b */
        sync(w); /* Keep this as a separate function so you can make it optional */
    }
}

/* Sync the data fields of the two separate structs */
static void sync(wrapperStruct* w)
{
    if (w != NULL)
    {
        memcpy(w->bp->data, w->ap->data, sizeof(w->bp->data));
    }
}

Then in your factory function you can create the wrapped pairs.

/* Create a wrapper */
wrapperStruct syncedPair = { &updateStructs, &someA, &someB };

You can then pass the pair where you need it, e.g. the process that is updating your aStruct, and use it like this:

/* Pass new data to the synced pair */
syncedPair.update( &syncedPair, &newDataSource );

Because C is not designed as an OO language, it does not have a this pointer and you need to pass around the explicit wrapper pointer. Essentially this is what happens behind the scenes in C++ where the compiler saves you the extra trouble.

If you need to sync a single aStruct to multiple bStructs, it should be quite simple to change the bp pointer to a pointer-to-array and modify the rest accordingly.

This might look like an overly complicated solution, but when you implement the logic once, it will likely save you from some manual labor in maintenance.