Writing Multiple Data Types to a File

To write multiple data types to a file, you can use SDL_RWwrite() for each type, ensuring you convert the data into a format that can be correctly interpreted when read back.

A common approach is to serialize the data, meaning you convert each piece of data into a sequence of bytes that can be written sequentially.

Here's an example where we write both an integer and a string to a file:

1#include <SDL.h>
2#include <iostream>
3#include <cstring>
4
5namespace File {
6void Write(const std::string& Path) {
7  SDL_RWops* Handle{
8    SDL_RWFromFile(Path.c_str(), "wb")
9  };
10
11  if (!Handle) {
12    std::cout << "Error opening file: "
13      << SDL_GetError();
14    return;
15  }
16
17  int MyInt{42};
18  SDL_RWwrite(Handle, &MyInt,
19    sizeof(int), 1); 
20
21  const char* MyString{"Hello World"};
22  size_t Length{strlen(MyString)};
23  SDL_RWwrite(Handle, &Length,
24    sizeof(size_t), 1); 
25  SDL_RWwrite(Handle, MyString,
26    sizeof(char), Length); 
27
28  SDL_RWclose(Handle);
29}
30}

Here's what happens in the code:

1. We first write an integer to the file by passing its memory address and size to SDL_RWwrite().
2. Next, we write the length of the string, which allows us to correctly read it back.
3. Finally, we write the string itself.

When reading the data back, you'll need to perform these steps in reverse, first reading the integer, then the string length, and finally the string.

By carefully writing each data type in sequence, you can store complex structures in a single file. Just make sure that when you read the data back, you do so in the same order.

This approach works for many types, including structs, arrays, and more. For more complex data types, you may want to implement custom serialization logic.