How to convert a signed integer to big-endian?

Let's assume I have a signed integer on my system and it is stored as little endian.

int32_t x = -456;

How do I make a function that converts this to big endian so I can store it in a file with different signedness from my system?

This is my attempt:

int32_t big_endian(int32_t x) {
    int sign = (x < 0) ? -1 : 1;
    uint32_t y = (uint32_t)x;
    
    // flip bits of y
    
    return (int32_t)y * sign;
}

I am concerned about that leftmost bit that determines the signedness, because I feel that converting to unsigned, and then flipping, will return the signedness bit to the wrong byte.

Calculating the bytes that represent an int32_t can be a slight nuisance due to the C standard not fully defining shifts with negative values. However, since the exact-width signed integer types are defined to use two’s complement, their representations are the same as for the corresponding unsigned integer type obtained by converting the signed type to the unsigned type. So we can convert to uint32_t and shift to obtain the desired bytes, as the following code demonstrates.

#include <stdlib.h>
#include <limits.h>


/*	Convert a big-endian object to a little-endian object or vice-versa,
   	in place.
*/
void ReverseEndian(void *p, size_t n)
{
	//	Convert to "unsigned char *" for convenience.
	unsigned char *pu = p;

	/*	Swap bytes at the front of the object with reflected bytes from the
		back.
	 */
	for (size_t i = 0; i < n/2; ++i)
	{
		unsigned char t = pu[i];
		pu[i] = pu[n-1-i];
		pu[n-i-1] = t;
	}
}


//	Store an int32_t as big-endian.
void StoreBigEndian(void *p, int32_t x)
{
	//	Convert to "unsigned char *" for convenience.
	unsigned char *pu = p;

	/*	Convert to uint32_t.  Since int32_t is defined to use two’s complement,
		uint32_t is represented with the sign bytes, and it avoids the sign
		issues.
	*/
	uint32_t u = x;

	/*	Shift each byte, starting with the least significant, to move it to
		the low byte, then store those bytes in big-endian order, starting
		with the highest addressed.
	*/
	for (size_t i = 0; i < sizeof u; ++i)
		pu[sizeof u - 1 - i] = u >> i*CHAR_BIT;
}


//	Store an int32_t as little-endian.
void StoreLittleEndian(void *p, int32_t x)
{
	//	Convert to "unsigned char *" for convenience.
	unsigned char *pu = p;

	/*	Convert to uint32_t.  Since int32_t is defined to use two’s complement,
		uint32_t is represented with the sign bytes, and it avoids the sign
		issues.
	*/
	uint32_t u = x;

	/*	Shift each byte, starting with the least significant, to move it to
		the low byte, then store those bytes in big-endian order, starting
		with the lowest addressed.
	*/
	for (size_t i = 0; i < sizeof u; ++i)
		pu[i] = u >> i*CHAR_BIT;
}


#include <stdio.h>


//	Print n bytes starting at address p.
static void PrintBytes(const void *p, size_t n)
{
	//	Convert to "unsigned char *" for convenience.
	const unsigned char *pu = p;

	printf("Hexadecimal");
	for (size_t i = 0; i < n; ++i)
		printf(" %0*x", (CHAR_BIT+3)/4, pu[i]);
}


#include <string.h>


int main(void)
{
	int32_t i = 0x12345678;

	//	Buffers for big-endian and little-endian representations.
	unsigned char BE[sizeof i];
	unsigned char LE[sizeof i];

	//	Store the value as big endian and display it.
	StoreBigEndian(BE, i);
	printf("Big Endian:  "); PrintBytes(BE, sizeof BE); printf(".\n");

	//	Store the value as little endian and display it.
	StoreLittleEndian(LE, i);
	printf("Little Endian:  "); PrintBytes(LE, sizeof LE); printf(".\n");

	//	Copy the bytes into new int32_t objects to reinterpret them.
	int32_t ibe, ile;
	memcpy(&ibe, BE, sizeof ibe);
	memcpy(&ile, LE, sizeof ile);

	if (ibe == i)
		printf("This system appears to be big endian.\n");
	else if (ile == i)
		printf("This system appears to be little endian.\n");
	else
		printf("This system appears to be neither big endian nor little endian.\n");

	//	Reverse the endianness and test for problems.
	ReverseEndian(BE, sizeof BE);

	if (memcmp(BE, LE, sizeof BE))
	{
		fprintf(stderr, "Error, big-endian bytes are inconsistent with little-endian bytes.\n");
		exit(EXIT_FAILURE);
	}
}

Don't reinvent the wheel when you need to convert your host's data to big-endian format. For 32-bit integer values, just use htonl():

> SYNOPSIS
>
> #include <arpa/inet.h>
>
> uint32_t htonl(uint32_t hostlong);
> uint16_t htons(uint16_t hostshort);
> uint32_t ntohl(uint32_t netlong);
> uint16_t ntohs(uint16_t netshort);
>
> DESCRIPTION
>
> These functions shall convert 16-bit and 32-bit quantities between network byte order and host byte order.
>
> On some implementations, these functions are defined as macros.
>
> The uint32_t and uint16_t types are defined in <inttypes.h>.
>
> RETURN VALUE
>
> The htonl() and htons() functions shall return the argument value converted from host to network byte order.

It's also available on Windows.