Convert a uint16_t to char[2] to be sent over socket (unix)

Why not just break it up into bytes with mask and shift?

 uint16_t value = 12345; char lo = value & 0xFF; char hi = value >> 8;

(edit)

On the other end, you assemble with the reverse:

 uint16_t value = lo | uint16_t(hi) << 8;

Off the top of my head, not sure if that cast is required.

char* pUint16 = (char*)&u16;

ie Cast the address of the uint16_t.

char c16[2];uint16_t ui16 = 0xdead;memcpy( c16, ui16, 2 );

c16 now contains the 2 bytes of the u16. At the far end you can simply reverse the process.

char* pC16 = /*blah*/uint16_t ui16;memcpy( &ui16, pC16, 2 );

Interestingly though there is a call to memcpy nearly every compiler will optimise it out because its of a fixed size.

As Steven sudt points out you may get problems with big-endian-ness. to get round this you can use the htons (host-to-network short) function.

uint16_t ui16correct = htons( 0xdead );

and at the far end use ntohs (network-to-host short)

uint16_t ui16correct = ntohs( ui16 );

On a little-endian machine this will convert the short to big-endian and then at the far end convert back from big-endian. On a big-endian machine the 2 functions do nothing.

Of course if you know that the architecture of both machines on the network use the same endian-ness then you can avoid this step.

Look up ntohl and htonl for handling 32-bit integers. Most platforms also support ntohll and htonll for 64-bits as well.

Sounds like you need to use the bit mask and shift operators.

To split up a 16-bit number into two 8-bit numbers:

• you mask the lower 8 bits using the bitwise AND operator (& in C) so that the upper 8 bits all become 0, and then assign that result to one char.
• you shift the upper 8 bits to the right using the right shift operator (>> in C) so that the lower 8 bits are all pushed out of the integer, leaving only the top 8 bits, and assign that to another char.

Then when you send these two chars over the connection, you do the reverse: you shift what used to be the top 8 bits to the left by 8 bits, and then use bitwise OR to combine that with the other 8 bits.