Question

I’m trying to modify some variables [not necessary from the same class/struct] from keyboard’s shortcuts, something like that:
A foo struct containing variables:

struct Foo {
    int a;
    float b;
};

struct Foo2 {
    int c;
};

And a main like:

int main() {
    Foo f;
    Foo2 f2
    void* p = &(f.a); //it could be &(f2.c)

    if ('A' key activated) {
        *p += 1;
    }
}

Currently, I’m stucked at this point:

error: invalid operands to binary expression ('void' and 'int')

The only way to make it work is to change:

*p += 1;

By:

*(int*)p += 1;

Which is not a good solution, because I should not know the type pointed by p. Is there a way to do that?

Answer 1

Edit: At first I didn’t realize that you want to have different types per entry. Based on the task of handling keyboard shortcuts, you could use a polymorphic class, and put instances of it into a std::map:

class KeyHandler {
public:
    virtual void onKeyStroke() = 0;
};

class MyHandler : public KeyHandler {
public:
    MyHandler(int& value) : myValue(value) {}

    virtual void onKeyStroke() {
        myValue_ += 1;
    }

private:
    int& myValue_; // Other subclasses could have other data
};

// Now place instances of different Handlers into a std::map
typedef std::shared_ptr<KeyHandler> PKeyHandler;
std::map<char, PKeyHandler> bindings;

bindings['A'] = PKeyHandler(new IncrementIntHandler(&someInt)); 
bindings['B'] = PKeyHandler(new IncrementFloatHandler(&someFloat));


// The actual input handler then just invokes
// the correct handler for a key stroke.
bindings[keyCode]->onKeyStroke();

That way, you can define a handler class for every action you want to support, and implement the corresponding logic into these classes. You could make the base class’ implementation just do nothing to handle non-mapped keys, etc.