Anonymous inner class in C++ (Java-style listener)

Question

My C/C++ skills are a bit rusty, and I've mostly been working in Java for the past few years. Now I just started playing around with Arduino, and made a simple button class. I want to add an event listener, so I did something like this:

class MyButton{
  public:
      MyButton(byte pin);
      bool isPressed();
      bool wasToggled();
      bool wasPressed();
      void eventLoop();
      inline void setListener(MyButtonListener* listener) { _listener = listener; }

  private:
      byte _pin;
      boolean _lastToggledState = false;
      MyButtonListener* _listener;
};



class MyButtonListener{
    public: 
        virtual void onPressed() = 0;

    private:
};

The eventLoop() method (which is intended to be called from the Arduino loop() function ), invokes the onPressed() method in the listener class:

void MyButton::eventLoop(){
    if( wasPressed() && _listener ){
        _listener->onPressed();
    }
}

So far, things are okay. But I can't figure out how to actually assign and use the listener in the main Arduino file. Coming from Java, I'm used to just doing something like

myBtn.setListener( new MyButtonListener(){
    void onPressed(){
        Serial.println("Pressed");
        toggleLed(); // toggleLed() is a method in the main Arduino file
    }
});

I got it to work in a very convoluted way, by declaring a new class which takes the toggleLed() method as an argument (because it can't be accessed from within the new class otherwise):

class BtnListener : public MyButtonListener{
    public:
        BtnListener(void* toggleFunction) : _toggleFunction(toggleFunction){ };

    private:
        void (*_toggleFunction)();

        void onPressed(){
            Serial.println("Pressed");
            _toggleFunction();
        };
};



myBtn.setListener( new BtnListener(toggleLed) );

Surely there must be a more convenient way of doing something like this in C++? It's doable (but ugly) with one listener - I can't even imagine the horror of having 10 buttons which all need different listener implementations...

C++ does not have anything similar to inline-generated anonymous classes, like Java. C++ is not Java and works in fundamentally different ways. In C++ the equivalent functionality gets implemented using inline lambdas, and type erasure using `std::function`. C++ has changed a lot over the last decade, or so. Without picking up [a good C++ book](https://stackoverflow.com/questions/388242/the-definitive-c-book-guide-and-list) and investing some time reading it, you will not get very far with modern C++. — Sam Varshavchik, Nov 09 '18 at 11:51
Variables and functions starting with _ are reserved for the compiler — Brandon, Nov 09 '18 at 11:51
@n.m. https://stackoverflow.com/questions/228783/what-are-the-rules-about-using-an-underscore-in-a-c-identifier — Brandon, Nov 09 '18 at 11:57
@Brandon `_Uppercases` are reserved everywhere, but `_lowercases` are only reserved in the global namespace. This is fine. — Quentin, Nov 09 '18 at 12:10

darune · Answer 1 · 2018-11-09T12:07:15.783

3

In your case, one or the simplest methods would be to store the listener as a std::function<void()> and don't have an actual class to model the buttonlistener at all (you can still have that if you really want to encapsulate that, but it's not neccesary). Then use a lambda function to the setListener call, something like this:

myBtn.setListener( [this]{
        Serial.println("Pressed");
        toggleLed(); // toggleLed() is a method in the main Arduino file
    });

edited Nov 09 '18 at 12:07

answered Nov 09 '18 at 12:01

darune

10,480
2
24
62

on what Arduino you tested it? – Juraj Nov 17 '18 at 17:05

score 3 · Accepted Answer · answered Nov 09 '18 at 13:25

Since the Arduino IDE by default doesn't seem to include <functional.h>, I wasn't able to use the answer using std::function<void()>. However, after some experimenting I realized there was an easier way, which also has the benefit of being able to model the listener.

The listener class simply contains function pointers to each listener callback function, and a constructor that takes an argument for each callback. Then it's very convenient to just create a new instance of the listener class and pass each callback as a lambda.

class MyButton{
    public:
        inline void setListener(MyButtonListener* listener) { _listener = listener; }

    private:
        MyButtonListener* _listener;          
 }


class MyButtonListener{
    public:
        MyButtonListener(void* onPressed, void* onToggled) : onPressed(onPressed), onToggled(onToggled) {};
        void (*onPressed)();
        void (*onToggled)();
};



void MyButton::eventLoop(){
    if( _listener ){
        if( wasPressed() ){
            _listener->onPressed();
        }

        if( wasToggled() ){
            _listener->onToggled();
        }        
    }
}



myBtn.setListener( 
    new MyButtonListener( 
        // onPressed
        [](){
            Serial.println("Pressed");
            toggleLed();
        },
        // onToggled
        [](){
            Serial.println("Toggled");
        }            
    )
);

Not sure if there are any drawbacks with this solution, but it works, is readable and is fit for use on Arduino.

Interesting, does that compile ? without warnings ? you had to resort to void* pointers which is (big) drawback but fixable. Right now you could have UB because of the lamdba to function pointer conversion. — darune, Nov 20 '18 at 10:43

Anonymous inner class in C++ (Java-style listener)

2 Answers2