Odtnhj

In my c++ program I have a structure containing four unsigned char members

struct msg

 unsigned char zero; unsigned char one; unsigned char two; unsigned char three;

and created an array of struct

msg myMsg[4] = 0x11,0x22,0xAA,0xCC,...,...,...;

now in a function I want to return an index of this array as an unsigned int

unsigned int procMsg(int n)
 return myMsg[n]; // of course this is worng

a value like: 0xCCAA2211

You can use shifting:

uint32_t little_endian;
uint32_t big_endian;
//...
big_endian = myMsg[0].zero << 24
 | myMsg[0].one << 16
 | myMsg[0].two << 8
 | myMsg[0].three;
little_endian = myMsg[0].three << 24
 myMsg[0].two << 16
 myMsg[0].one << 8
 myMsg[0].zero;

As you can see, with multi-byte integers, there are two general orderings: Big Endian and Little Endian. Big Endian has the Most Significant Byte (MSB) first. The Little Endian has Least Significant Byte (LSB) first.

In general the above method is more efficient than using a loop.

consider this:

a message like this: 0x01, 0x01, 0x01, 0x01 can be parsed as

00000001 00000001 00000001 00000001(bin) = 16.843.009(dec)

so you just need to take every char and shift them according to its position
i.e.

char0 not shifted at all,

char1 shifted 8 positions to the left (or multiply by 2^8)

char2 shifted 16 positions to the left (or multiply by 2^(8*2))

char3 shifted 24 positions to the left (or multiply by 2^(8*3))

unsigned int procMsg(Message &x)

 return (x.three << 24) 

int main(int argc, char *argv)

 //0 1 2 3
 Message myMsg[4] = 0x01, 0x01, 0x01, 0x01, //00000001 00000001 00000001 00000001 = 16.843.009
 0xFF, 0x00, 0xAA, 0xCC, //00000001 00000001 00000001 00000001 = 3.433.693.439
 0x01, 0x00, 0x00, 0x00, //00000001 00000001 00000001 00000001 = 1
 0x00, 0x00, 0x00, 0x00 //00000000 00000000 00000000 00000000 = 0
 ;

 for (int i = 0; i<4; i++)
 
 Message x = myMsg[i];
 std::cout << "res: " << procMsg(myMsg[i]) << std::endl;
 

 return 0;