The examples all use unsigned integers. Do I need to handle endianness differently for signed integers?

Question

Ryan McCombe · Accepted Answer

The good news is that signed and unsigned integers have the same byte representation when it comes to endianness - the only difference is how those bytes are interpreted. Let's explore this in detail:

Basic Comparison

Here's a program that demonstrates how signed and unsigned integers are handled:

1#include <iostream>
2#include <iomanip>
3#include "SDL.h"
4
5void PrintBytes(const char* Label,
6                const void* Data,
7                size_t Size) {
8  auto* Bytes = static_cast<const uint8_t*>(
9    Data);
10  std::cout << Label << ": ";
11
12  for (size_t i = 0; i < Size; ++i) {
13    std::cout << std::hex << std::setw(2)
14      << std::setfill('0')
15      << static_cast<int>(Bytes[i]) << " ";
16  }
17  std::cout << std::dec << '\n';
18}
19
20int main() {
21  // Compare signed and unsigned representations
22  int32_t Signed{-42};
23  uint32_t Unsigned{static_cast<uint32_t>(-42)};
24
25  PrintBytes("Signed  ", &Signed,
26             sizeof(Signed));
27  PrintBytes("Unsigned", &Unsigned,
28             sizeof(Unsigned));
29
30  // Write both to file
31  SDL_RWops* Handle{
32    SDL_RWFromFile("numbers.bin", "wb")};
33  if (!Handle) { return 1; }
34
35  SDL_WriteLE32(Handle, Unsigned); 
36  SDL_RWseek(Handle, 0, RW_SEEK_SET);
37
38  // Read back as both signed and unsigned
39  int32_t ReadSigned{ 
40    static_cast<int32_t>(SDL_ReadLE32(Handle))};  
41
42  SDL_RWseek(Handle, 0, RW_SEEK_SET);
43  uint32_t ReadUnsigned{SDL_ReadLE32(Handle)};
44
45  SDL_RWclose(Handle);
46
47  std::cout << "\nRead back values:\n"
48    << "As Signed  : " << ReadSigned << '\n'
49    << "As Unsigned: " << ReadUnsigned << '\n';
50}

1Signed  : d6 ff ff ff
2Unsigned: d6 ff ff ff
3
4Read back values:
5As Signed  : -42
6As Unsigned: 4294967254

Key Points

The byte order functions (SDL_WriteLE32(), SDL_ReadLE32(), etc.) treat all integers as unsigned
You can safely cast between signed and unsigned after reading/writing
The sign bit is just another bit - it gets swapped along with everything else

Here's an example showing how to write a helper function that handles both types:

1#include <iostream>
2
3#include "SDL.h"
4
5template <typename T>
6void WriteNumber(SDL_RWops* Handle, T Value) {
7  if constexpr (sizeof(T) == 2) {
8    SDL_WriteLE16(Handle,
9                  static_cast<Uint16>(Value));
10  } else if constexpr (sizeof(T) == 4) {
11    SDL_WriteLE32(Handle,
12                  static_cast<Uint32>(Value));
13  } else if constexpr (sizeof(T) == 8) {
14    SDL_WriteLE64(Handle,
15                  static_cast<Uint64>(Value));
16  }
17}
18
19int main() {
20  SDL_RWops* Handle{
21    SDL_RWFromFile("numbers.bin", "wb")};
22  if (!Handle) { return 1; }
23
24  // Works with both signed and unsigned
25  WriteNumber(Handle, int32_t{-42}); 
26  WriteNumber(Handle, uint32_t{42}); 
27  WriteNumber(Handle, int16_t{-12345}); 
28  WriteNumber(Handle, uint64_t{9999}); 
29
30  SDL_RWclose(Handle);
31}

Remember:

Endianness is about byte order, not value interpretation
Sign conversion happens after byte order is handled
Use appropriate casts when reading values back
The same byte-swapping functions work for both signed and unsigned

Byte Order and Endianness

Signed vs Unsigned Endianness

Basic Comparison

Key Points

Byte Order and Endianness

Game Development with SDL2

Questions & Answers