c++ class constructors automatically mapping objects to an event handler - c++

Question

I'm currently working on a little project for my beaglebone. Essentially the goal is to create a framework which gives the full power of c++ as opposed to the beaglebone's stock javaScript framework, but is also as easy to use for the developer as the arduino framework is.
One of the things i've built are premade classes for different types of simple GPIO interrupts like buttons, rotary encoders, etc, so the developer just has to define a button, and tell it which GPIO pin on the beaglebone it's connected too.
Right now I have to manually add the interrupt object's pollInterupt() function to the main loop so the program can repeatedly check the state of the inerupts GPIO pin.
Here is the problem: I want to add code to the button's class constructor function, that when defined, will automatically pass itself to an interrupt handler behind the scene to repeatedly run the new object's pollInterupt() function, so the developer never has to do anything more complicated than defining the button.
I seem to be hitting a brick wall though. Trying to make the framework simple for the end user, is meaning that the code behind the scene is getting stupidly complicated. The best way i could think of automatically handling the defined interrupt objects, is a link list. This is what the prototype code is looking like at the moment.
#include <iostream>
class interuptButton;
class interuptHandler;
class interuptHandler{
public:
class node{
public:
node *next;
node *prev;
public:
void *interupt;
};
node *first;
node *last;
node *current;
node *temp;
public:
interuptHandler(){
first = new node;
last = new node;
first -> prev = NULL;
first -> next = last;
last -> prev = first;
last -> next = NULL;
}
void add(void *_interupt){
temp = new node;
current = last -> prev;
current -> next = temp;
temp -> prev = current;
temp -> next = last;
last -> prev = temp;
temp -> interupt = _interupt;
}
void run(){
current = first -> next;
while(current -> next != NULL){
std::cout << current -> interupt << std::endl;
// std::cout << current -> interupt -> pin << std::endl;
// current->interupt->pollInterupt();
// std::cout << reinterpret_cast < interuptButton* > (current->interupt)->pin << std::endl;
current = current -> next;
}
}
}handler;
class interuptButton{
public:
int pin;
bool value;
public:
interuptButton(int _pin){
pin = _pin;
handler.add(this);
}
void pollInterupt(){
std::cout << "check pin " << pin << " to see if the GPIO has changed" << std::endl;
}
};
int main(int argc, char **argv){
interuptButton buttonA(41);
interuptButton buttonB(45);
interuptButton buttonC(43);
handler.run();
return 0;
}
The system seems to be working, and the interuptButton constructor is successfully passing the newly created objects to the interuptHandler's link list, which it can then print the memory address for in the run() function with the output:
bin/./test
0x7fff5fbff9e0
0x7fff5fbff9d0
0x7fff5fbff9c0
The problem is when I uncomment any of the other lines in run(), where i try to access the pointer object's variables or functions, g++ starts throwing errors.
The first two lines return:
src/main.cpp: In member function ‘void interuptHandler::run()’:
src/main.cpp:47: error: ‘void*’ is not a pointer-to-object type
make: *** [all] Error 1
and the third line returns:
src/main.cpp:49: error: invalid use of incomplete type ‘struct interuptButton’
src/main.cpp:4: error: forward declaration of ‘struct interuptButton’
make: *** [all] Error 1
Any advice on how to access those objects variables and functions via their pointers would be much appreciated.
Better yet, if anyone has a better way to automatically send objects to a behind the scene event handler, I'm all ears.

Answer 1

In the node structure, the interrupt pointer is a pointer to void which means that it can point to any type. However, the compiler doesn't know what it points to, so you have to tell the compiler what type it really points to by using typecasting:
reinterpret_cast<interuptButton*>(current->interrupt)->pollInterrupt();
As for the other problem, you have a circular dependency. The class interruptHandler depends on the class interruptButton and the other way around. This you have to solve by separating the definition and the implementation of one or both classes. The simplest way would be to just put the interruptButton class definition above the interruptHandler definition, and place the implementation, i.e. the actual code, of interruptButton after the interruptHandler class definition.
If you want to use multiple interruptable classes, not only the interruptButton class, you should use inheritance and abstract base classes with virtual functions. Then you won't need the void pointer or typecasting:
struct baseIntertuptable
{
virtual void pollInterrupt() = 0;
};
struct interruptHandler
{
private:
struct node
{
// ...
baseInterruptable* interrupt;
};
public:
void run()
{
// ...
current->interrupt->pollInterrupt();
// ...
}
};
class interruptButton : public baseInterruptable
{
public:
void pollInterrupt()
{
// ...
}
};
This should also solve your problem with the circular dependencies of the class definitions, as the abstract base class baseInterruptable is now fully defined before it's used and the interruptHandler class only uses that one.

Answer 2

Do you need to start moving definitions of functions into .cpp files? Looks like you are accessing the internals of interuptbutton before its defined.
Or since it is just 1 big .cpp file, you can define the run function just before main to fix your second set of errors.
First error is self explanatory, maybe you should make a Interrupt interface and keep pointers to it, instead of to void*? reinterpret_casting just makes everything so ugly.
class IInterupt{
// other stuff common to all interupt classes
void pollInterupt() = 0; // pure virtual force all inheriting classes to implement.
}
class interuptButton : public IInterupt{ //bla bla }
class node{
public:
node *next;
node *prev;
public:
IInterupt*interupt;
};