Multiple threads cannot access the same pointer without error [closed] - c++

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Closed 8 years ago.
Edit the question to include desired behavior, a specific problem or error, and the shortest code necessary to reproduce the problem. This will help others answer the question.
This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.
Improve this question
I am making an application with GLFW3 (window library), and I my OS is Windows 8.1.
My error: I make a pointer in my main thread and the window's thread gets an access violation when it tries to use it.
In my application I am trying to make an input handler class that takes in events from the window and sends them to all objects that subscribe to the event.
To do this, I have all objects that want to listen inherit InputListener:
class InputListener{
public:
virtual void onKeyDown(int key) = 0;
};
To subscribe to an event, a object must use a pseudo-global (reference passed to classes on construction) wrapper variable which contains my InputHandler:
// My global wrapper
#include "InputHandler.h"
class Centrum{
public:
InputHandler inputHandler;
public:
Centrum(){}
};
InputHandler
class InputHandler{
private:
unsigned numEvents;
InputListener* key_down; // Only trying to test on one subscriber for now.
public:
InputHandler();
void registerKeyDown(InputListener* listener, int key);
void key_event(int key, int action); // Is indirectly called by glfw window (same thread though)
};
// Implementation
InputHandler::InputHandler(){
numEvents = 0;
}
void InputHandler::registerKeyDown(InputListener* listener, int key){
// This is called from my main thread
key_down = listener;
key_down->onKeyDown(key); // Properly calls function on my Camera class which inherits InputListener
numEvents++;
printf("yes %u\n", numEvents);
}
void InputHandler::key_event(int key, int action){
// This is called by the window's thread (glfw automatically makes this thread)
printf("failure %u\n", numEvents); // Properly prints out numEvents
key_down->onKeyDown(key); // Runtime error here, access violation
}
Example of subscribing to input:
Camera::Camera(Centrum& g_centrum){
this->g_centrum = g_centrum;
[...]
g_centrum.inputHandler.registerKeyDown(this, GLFW_KEY_W);
}

Answer 1

The variable being pointed to was dying before it could be used. So, when the thread tried to use it, it threw a runtime error.

Answer 2

In this line you are copying the Centrum:
this->g_centrum = g_centrum;
You then register with the copy (which makes the first call to onKeyDown which naturally works). But you haven't registered with the original Centrum, so it has no key_down to call, so when it attempts to do so, without checking if the pointer is valid, it fails.
I'd make g_centrum a pointer, and probably use pointers rather than references to Centrum throughout.

Answer 3

Threads have separate stacks, so objects can only be accessed by several thread if they are heap-allocated.
Furthermore you should protect against concurrent access to those objects (or at least to the concurrent data) via mutexes.
If Camera is instanciated in the windows thread, you will create a copy of centrum.
Camera::Camera(Centrum& g_centrum){
this->g_centrum = g_centrum;
[...]
g_centrum.inputHandler.registerKeyDown(this, GLFW_KEY_W);
}
You should instanciate your Centrumlike so Centrum *mycentrum = new Centrum() and pass it as a pointer to your Camera.