freeing C memory automatically using `std::unique_ptr` and `std::shared_ptr`

this approach has the nice advantage of being really simple, but it doesn’t work well if you build your codebase on RAII.

but remember the rule of three - if you declare a destructor, you pretty much always also want to declare a copy constructor, and a copy assignment operator

that alone is cool, but it would be nice if we could move a window to a different location in memory instead of having to keep it in place.

this fulfills the rule of five, which says that if you follow the rule of three and would like the object to be movable, you will want a move constructor and move assignment operator.

with all of this combined, our final window class looks like this:

struct window
{
    SDL_Window* raw = nullptr;

    window(const char* title, int x, int y, int w, int h, int flags)
        : raw(SDL_CreateWindow(title, x, y, w, h, flags))
    {}

    ~window()
    {
        if (raw != nullptr) {
            SDL_DestroyWindow(raw);
            raw = nullptr;
        }
    }

    window(const window&) = delete;
    void operator=(const window&) = delete;

    window(window&& other)
    {
        raw = other.raw;
        other.raw = nullptr;
    }

    window& operator=(window&& other)
    {
        raw = other.raw;
        other.raw = nullptr;
        return *this;
    }
};

naturally it has to know how to perform the freeing. the standard library designers could have just assumed that all allocations are created with new and deleted with delete, but unfortunately the real world is not so simple. we have C libraries to interface with after all, and there destruction is accomplished simply by calling functions!

to set a custom deleter for an std::shared_ptr, we provide it as the 2nd argument of the constructor. so to automatically free our SDL_Window pointer, we would do this:

int main(void)
{
    SDL_Init(SDL_INIT_VIDEO);

    std::shared_ptr<SDL_Window> window{
        SDL_CreateWindow(
            "Hello, world!",
            SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
            800, 600,
            0
        ),
        SDL_DestroyWindow,
    };

    bool running = true;
    while (running) {
        SDL_Event event;
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                running = false;
            }
        }
    }
}

and that’s all there is to it!

using std::shared_ptr does have a downside though, and it’s that there is some extra overhead associated with handling the shared pointer’s control block.

now we can delete an SDL_Window using our custom deleter like so:

std::unique_ptr<SDL_Window, function_delete<SDL_Window, SDL_DestroyWindow>> window{
    SDL_CreateWindow(
        "Hello, world!",
        SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
        800, 600,
        0
    ),
};

the unfortunate downside to this approach is that you can get pretty abysmal template error messages upon type mismatch:

void example(const sdl::window& w);

int main(void)
{
    example(1);

    // ...
}

sdl2.cpp:36:5: error: no matching function for call to 'example'
   36 |     example(1);
      |     ^~~~~~~
sdl2.cpp:21:6: note: candidate function not viable: no known conversion from 'int' to 'const sdl::window' (aka 'const unique_ptr>') for 1st argument
   21 | void example(const sdl::window& w);
      |      ^       ~~~~~~~~~~~~~~~~~~~~
1 error generated.