chip-8 | A CHIP-8 emulator in Go | Emulator library

You are not reading. You need to use a "read" function to read from the file. Please read here

Replace

Assuming your stack is something like std::array you can do:

If code is always known at compile time, make it a template parameter:

It appears that your issue is that you are incrementing the PC again after assigning it in the JMP instruction (0x1nnn) (You can see the discrepancy in your debug output). So after the current executeOpcode cycle, the execution returns to this.step and hits this line:

You have two or more cpp files. Each forms a compilation unit. (A .h you include becomes part of each compilation unit separately; the notion of compilation unit applies after preprocessing is done.)

Static global variables are not linked between compilation units, they're private to the unit they're defined in.
static uint16_t programCounter is thus local to each cpp file.

As a general rule:

1. Stop using global variables, especially mutable ones. Pass shared state explicitly. Use a class or struct.
2. Especially stop using mutable static variables in header files. That is insane.
3. Check the address of data when things don't make sense.

Be aware that static has a different meaning within classes and functions that it does at global scope. Regular globals already have static storage class (same as static variables), but with global cross-file visibility.

Let me start with a recommendation - if you're at all interested in an answer, please don't make it harder to answer your question than it needs to be. Think how it looks for others - some bulk of code, with problem seemingly in not drawing anything; why this example have to have 6 files? Why does it depend on external file which we don't have and hence have literally no way to verify? Surely it is possible to shrink it down to 30 lines of single file with just init and render - literally any "hello world" for SDL2 will do. And when it works and your code doesn't - you start checking what's different.

Now to your question. You can't draw anything from your main loop because your window and renderer here are NULL - it was initialised to NULL and never set to anything else. It appears you have misconception of how function arguments works - in C, funciton arguments are passed by value, and any modification of that value is made to local funciton copy. When you pass an int, function gets copy of that int, and don't push any changes back. If you pass SDL_Window*, then you pass value of that pointer (in your case, NULL); when you do SDL_CreateWindow, you assign it to local variable and once angain can't return it back to caller, where it stays NULL. So all your render calls are passing NULL as renderer, which naturally isn't a valid renderer.

The same thing appears in your close - you're trying to reset passed copies to NULL, but it makes no sense, as you can't modify external value, only function-local copy.

Programming classes often teach that there is "pass by value" and "pass by reference", which I suppose is a source of that confusion. I'd rather say there is no pass-by-reference in C, you always pass value, but pointer is a value too. To be able to modify data we pass pointer to that data; to mutate int you may pass int*, but to mutate SDL_Window* you'll need to get pointer to that pointer - SDL_Window**. Take a look at how SDL itself does it: https://wiki.libsdl.org/SDL_CreateWindowAndRenderer .

So, in short - make your init to be int init(SDL_Window **window, SDL_Renderer** renderer, int width, int height); (you don't need const int here either, as these are copies of width and height) instead, and modify its code accordingly. And check values of window and renderer after that call (debugger, debug printf, if(window==NULL) anything goes). init could be something like

Why doesn't the linker work with this? Are any other compiler flags required?

Yes, you need to tell the linker which libraries to link against, e.g.: