Communication protocol implementation : Array vs Structure

Please advise which coding style approach is better: Variant A or Variant B?
Major question is whether to use arrays or structure in example function below.
Thank you for advice.

Common definitions:

Code:

---

typedef struct MsgHeader
{
    int MagicNumber;
    int OpCode;
    int DataSize;
    int Checksum;
    int Err;
}
MsgHeader;

typedef struct
{
    MsgHeader hdr;
    int data[10];
}
CommBlock;
           
typedef struct
{
    int nMinorVersion ;
    int nMajorVersion ;
    int nBuildNumber ;
}
CmdGetVersion;

---

Variant A:

Code:

---

int GetVersion(CommBlock* pCommand)
{
    int enErr = eVMD_NOERROR ;
   
    // Check op code
    if(pCommand->hdr.OpCode != eVMD_GET_VERSION )
    {
        enErr = eVMD_BAD_OPCODE ;
    }

    pCommand->hdr.DataSize = 3 ;
               
    pCommand->data[VMD_CMD_GET_VERSION_0] = VMD_MINOR_VERSION ; // Minor VMD software version
    pCommand->data[VMD_CMD_GET_VERSION_1] = VMD_MAJOR_VERSION ; // Major VMD software version
    pCommand->data[VMD_CMD_GET_VERSION_2] = VMD_BUILD_NUMBER ;  // VMD build number 
   
    return enErr ;
}

---

Variant B:

Code:

---

int GetVersion(CommBlock* pCommand )
{
    int enErr = eVMD_NOERROR ;
    CmdGetVersion objReply ;
 
    memset(&objReply, 0, sizeof(CmdGetVersion ) ;
   
    // Check op code
    if(pCommand->hdr.OpCode != eVMD_GET_VERSION )
    {
        enErr = eVMD_BAD_OPCODE ;
    }

    pCommand->hdr.DataSize = 3 ;
               
    objReply.nMinorVersion = VMD_MINOR_VERSION ; // Minor VMD software version
    objReply.nMajorVersion = VMD_MAJOR_VERSION ; // Major VMD software version
    objReply.nBuildNumber = VMD_BUILD_NUMBER ;  // VMD build number 
   
    memcpy(pCommand->data, &objReply, sizeof(CmdGetVersion ) ;

    return enErr ;
}

---

Assuming they behave the same (it looks like they do) it doesn't matter: Variant A doesn't copy data from a temporary area to the final destination -- but the compiler will optimize it out of Variant B anyway.

If you must choose one for performance reasons: measure!
If you must choose one for resource usage reasons: measure!
If you must choose one for electricity usage reasons: measure!

Style wise: I prefer Variant A, but use whichever you feel more confortable with.

Data structure alignment - Wikipedia, the free encyclopedia
Endianness - Wikipedia, the free encyclopedia
If you're trying to communicate this information over some external interface (be it a file, network, or shared memory), then these issues will bite you at some point.

if you use a struct you have to be sure the layout of the struct is consistent across platforms. When you declare a struct, the compiler implementation can decide to pad the struct for alignment purposes depending on the data types in the struct. so the layout of the variables might not be contiguous. if the other side of your protocol is on a different machine with a different compiler it might lay out the structure differently. you could use a 'pack' directive to force out the padding but even that is implementation dependent. In this case since the struct contains all ints, it probably would be ok, but that is just an assumption. So for actually loading data into a packet, using an array is more reliable.