How Do I Box Disparate "Resource" Pointers for SDL2? - c++

Question

I want to implement a resource loader, and conceptually, it feels like all the resources in SDL2 are the same; you need to free the resource when finished, SDL_Texture* with SDL_DestroyTexture, Mix_Music* with Mix_FreeMusic, Mix_Chunk* with Mix_FreeChunk, TTF_Font* with TTF_CloseFont. All that changes is the name of the "deleter" function, so I would like to box these all so I don't need 4 different std::maps for each type of resource.
I've implemented a small class that boxes the data, but I'm having trouble getting the types back when using generics. Specifically, I get "SDL_Texture* is an incomplete type" when I try to cast the void* back to SDL_Texture* via value.get<SDL_Texture*>()
ValueBox.h
// helper class used to box various pointers for sdl, like textures, chunks, fonts, etc
class ValueBox {
public:
std::function<void(void)> clean;
void* data;
ValueBox(void* data, std::function<void(void)> clean) : data(data), clean( std::move(clean) ) {}
~ValueBox() {
clean();
}
template<typename T>
T get() {
return dynamic_cast<T>(data);
}
};
How do I implement a class that allows me to box the pointers so that I don't need four different maps in the loader? (Or am I doing something that I shouldn't?)

Answer 1

dynamic_cast only makes sense when you're casting to a polymorphic type (or void*), from a polymorphic type. A polymorphic type is a class (or a struct, which is formally also a class) that has (possibly inherits) at least one virtual function.
None of the types you listed are polymorphic (because they come from C libraries, and C doesn't have virtual functions). But even if they were, void itself is not polymorphic, so it wouldn't work anyway.
Additionally, you must dynamic_cast to a pointer or reference, but it doesn't matter because of the above.
Since all your resources are pointers, you can [ab]use std::unique_ptr to dispose of them automatically. Here's an example for FILE * and std::fopen:
using file_ptr = std::unique_ptr<FILE, std::integral_constant<decltype(&std::fclose), std::fclose>>;
int main()
{
file_ptr f(std::fopen("foo.txt", "rb")); // This is closed automatically.
}
However, I don't recommend doing so, because it only works with pointers. If you encounter a new type of resource that's not a pointer, you'll have to manage it differently, making your code inconsistent.
You could in theory write a class similar to std::unique_ptr that's not limited to pointers, but after trying this myself, I decided that it's not very convenient and not worth the effort.
I suggest writing an individual class for each kind of resource, using following pattern:
class FilePtr
{
FILE* file = nullptr;
public:
FilePtr() {} // Optional
FilePtr(const char *filename, const char *mode) // Change parameters as needed.
{
file = std::fopen(filename, mode);
if (!file)
throw std::runtime_error("Can't open file!");
}
FilePtr(FilePtr &&other) noexcept : file(std::exchange(other.file, {})) {}
FilePtr &operator=(FilePtr other) noexcept
{
std::swap(file, other.file);
return *this;
}
~FilePtr()
{
if (file)
std::fclose(file);
)
[[nodiscard]] explicit operator bool() const {return bool(file);} // Optional.
// Add more functions as needed.
};
Since those wrappers are so simple, you can easily write them for each kind of resource.
Having individual classes also allows you to add resource-specific functions to them.
class that allows me to box the pointers so that I don't need four different maps in the loader?
I would use different maps. This means you don't need to validate resource type at runtime, meaning one less failure point.
But regardless of the number of maps, you can inherit your wrapper classes from a single base, to reduce code duplication.
If you make the base polymorphic, you'll be able to store the resources in a single map of shared_ptrs (or unique_ptrs) to that base.