C++/Arduino Pass a function as argument

Question

I am trying to create a callback style API and am fairly new to C++. I keep getting the error error: invalid use of non-static member function but am not sure the next steps. I would like to have the ability to pass an member function as an argument to another class.

The code is something like

class Button {
  int buttonDownTime = 0;
  int debounceTime = 2000;

  ...

  template<typename Callback>
  void debounce(Callback func) {
    if (millis() - buttonDownTime > debounceTime) {
      func();
    }
  }
}

class Player {
  int playerCount = 0;

  void incriment() {
    playerCount++;
  }
}

void loop() {

  ...

  button.debounce(player.incriment);
}

EDIT:

So I want to thank everyone for the awesome answers so far but I learned something since posting. Arduino's AVR does not include C++'s <functional>. Is this a possible thing to do without that library?

Thank you again!

You want [`std::function`](http://en.cppreference.com/w/cpp/utility/functional/function). — Captain Obvlious, Jun 19 '17 at 20:02
We really need a canonical for this. Who feels like making one? — Brian Bi, Jun 19 '17 at 20:02
@CaptainObvlious saddly functional is not included in AVR for arduino :( — austinbv, Jun 19 '17 at 21:45
@austinbv I updated my answer to get rid of all uses of the standard library, since it doesn't seem arduino provides any of it. — Miles Budnek, Jun 20 '17 at 00:27
That's one of the many reasons I stopped using the arduino IDE, and the arduino api to program atmega's — Michaël Roy, Jun 20 '17 at 03:59
There are many implementations of the Standard Template Library (STL) for Arduino which include the functional library. Here is an example https://github.com/maniacbug/StandardCplusplus but there are more of you just search for Arduino STL — Jesse Laning, Jun 21 '17 at 01:36

Miles Budnek · Answer 1 · 2017-06-20T00:32:54.777

Non-static member functions require an object to work on, and thus can't be passed and called like normal function pointers.

The simplest way to make your debounce method work, would be to use a lambda that captures your player object and calls increment on it:

class Button {
  //...
  template<typename Callback>
  void debounce(Callback&& func) {  // <<-- Note the && here, without
                                    //      it func would need to be
                                    //      copied
    if (millis() - buttonDownTime > debounceTime) {
      func();
    }
  }
}

void loop() {
  //...
  button.debounce([&player](){ player.incriment(); });
}

With a little bit of extra effort, you could implement something similar to C++17's std::invoke to uniformly invoke any type of callable. Since you're on Arduino and don't have access to the C++ standard library, you'll need to implement std::remove_reference and std::forward yourself as well:

template <typename T>
struct remove_reference
{
  using type = T;
};

template <typename T>
struct remove_reference<T&>
{
  using type = T;
};

template <typename T>
struct remove_reference<T&&>
{
  using type = T;
};

template <typename T>
constexpr T&& forward(typename remove_reference<T>::type& t)
{
  return static_cast<T&&>(t);
}

template <typename T>
constexpr T&& forward(typename remove_reference<T>::type&& t)
{
  return static_cast<T&&>(t);
}

template <typename Callable, typename... Args>
auto invoke(Callable&& func, Args&&... args) 
    -> decltype(forward<Callable>(func)(forward<Args>(args)...))
{
    return forward<Callable>(func)(forward<Args>(args)...);
}

template <typename Callable, typename Class, typename... Args>
auto invoke(Callable&& method, Class&& obj, Args&&... args)
    -> decltype((forward<Class>(obj).*method)(forward<Args>(args)...))
{
    return (forward<Class>(obj).*method)(forward<Args>(args)...);
}

class Button {
  //...
  template<typename Callback, typename... Args>
  void debounce(Callback&& func, Args&&... args) {
    if (millis() - buttonDownTime > debounceTime) {
      invoke(forward<Callback>(func),
             forward<Args>(args)...);
    }
  }
}

void loop() {
  //...
  button.debounce(&Player::increment, player);
}

This doesn't quite do everything that C++17's std::invoke does, but it's close enough to implement a basic callback. It also gives you extra flexibility in that you could pass additional arguments to debounce and they will be passed along to your callback:

void foo(int num) { /*...*/ }

void loop() {
    Button b;
    b.debounce(foo, 42);
}

This doesn't really work if you need to save the callback and call it later, but it doesn't look like that's what you're trying to do.

score 2 · Answer 2 · answered Jun 19 '17 at 20:27

In C++, the class name (Player) would be part of function signature, and the syntax becomes non-trivial. Templates do not resolve it in an elegant way, and even what Boost gives you (look here), is not really elegant (in my book).

Here is a simpler syntax which achieves the same goal.

class Button {
  int buttonDownTime = 0;
  int debounceTime = 2000;

  public:
  template<typename CallbackClass>
  void debounce(CallbackClass* po) {
    if (millis() - buttonDownTime > debounceTime) {
      po->increment();
    }
  }
};

class Player {
  int playerCount = 0;

  public:
  void increment() {
    playerCount++;
  }
};

int main() {
  Button button;
  Player player;
  button.debounce(&player);
}

This is great but limits you to only being able to increment a player on debounce, — austinbv, Jun 19 '17 at 22:05
@austinbv, no this will let you increment any object that has an increment method. The compiler will generate a separate debounce method for each type that is passed to it. — diverscuba23, Jun 20 '17 at 02:18

Didac Perez Parera · Answer 3 · 2017-06-19T22:29:21.797

Another valid approach is to define an interface with the pure virtual func() method so that you can pass an implementation of this interface to your debounce() method and call its func() method there.

class YourInterface {
public:
  virtual void func() = 0;
};

class Button {
public:
  int buttonDownTime = 0;
  int debounceTime = 2000;

  ...

  void debounce(YourInterface yourInterface) {
    if (millis() - buttonDownTime > debounceTime) {
      yourInterface->func();
    }
  }
}

class Player {
public:
  int playerCount = 0;

  void increment() {
    playerCount++;
  }
}

void loop() {

  ...

  button.debounce(player.increment);
}

C++/Arduino Pass a function as argument

3 Answers3