C++ lambda doesn't deduce function overloading

Question

I'm defining a class like this:

class foo {
public:
  // I define const and non-const versions of the 'visit' function
  // nb. the lambda is passed by reference
  virtual void visitWith(std::function<void(foo&)>&);
  virtual void visitWith(std::function<void(const foo&)>&) const;
};

foo can have children so the idea is to visit a foo and all it's children recursively.

When I try to use it, eg. like this:

foo f;
f.visitWith([&](const foo&) {
  // Do something here
});

I get compiler errors. The compiler can't figure out what to do.

I can make it work it by adding a typecast like this:

foo f;
f.visitWith( (std::function<void(const foo&)>) [&](const foo&) {
  // Do something here
});

But that's horrible.

How can I get it to work neatly?

Edit:

This may be a problem with Visual C++, it refuses to compile the code given here:

https://ideone.com/n9bySW

The VC++ output when I try to compile it is:

Edit2: Nope, Visual C++ is correct, the code is ambiguous. See my solution below...

Answer 1

A lambda is a compiler-generated type, it is not an instance of std::function, but it is assignable to one.

Your visitWith() method takes a std::function by non-const reference, which means it requires a pre-existing std::function object, eg:

std::function<void(const foo&)> func = [&](const foo&) {
    // Do something here
};
foo f;
f.visitWith(func);

Passing a lambda directly to visitWith() would require the compiler to create a temporary std::function object, but a non-const reference cannot bind to a temporary object. That is why your original code fails to compile.

For what you are attempting, you will have to pass the std::function either by value or by const-reference instead:

class foo {
public:
    void visitWith(std::function<void(foo&)>);
    void visitWith(std::function<void(const foo&)>) const;
};

Live Demo

class foo {
public:
    void visitWith(const std::function<void(foo&)> &);
    void visitWith(const std::function<void(const foo&)> &) const;
};

Live Demo

Answer 2

I reported this "bug" to Microsoft and got a reply, here:

https://developercommunity.visualstudio.com/content/problem/1201858/c-stdfunction-overloading-fails.html

Short version: Visual C++ is handling it correctly, ideone is wrong.

In the end I solved it by adding a third overload to foo which can add const-ness to an object, like this:

class foo {
public:
  // Use typedefs so that all the code that comes after these two functions is neater
  typedef std::function<void(Branch&)>visitor;
  typedef std::function<void(const Branch&)>const_visitor;
  
  virtual void visitWith(const visitor&);
  virtual void visitWith(const const_visitor&) const;

  // This is to thunk the third case that can happen when you start
  // a const visit from a non-const foo.
  void visitWith(const const_visitor& v) {
    static_cast<const foo*>(this)->visitWith(v);  // Add const-ness
  }

};

Now the code works, eg.:

foo f;
f.visitWith([](const foo& f) {
    std::cout << "visited a const foo!" << std::endl;
});