Boost C++ Libraries: Ticket #3270: Ambiguous conversion, even though no conversion exists

Steven Watanabe — Fri, 17 Jul 2009 16:20:55 GMT

Unfortunately, in this case, there does not even exist a conversion from "class A" to the function type! To test that, just comment the first definition of B::f():

Any type can be converted to a boost::function. The declaration of the conversion always exists, which is all that the compiler checks for in overload resolution. The conversion doesn't compile unless the type has a function call operator.

I think that this can be considered a bug. Or what else can I do in this case?

Did you really intend to make the overload for A const and the overload for boost::function non-const?

The following compiles for me

#include <boost/function.hpp>
struct A {};
struct B {
  void f(const A &a) const {}
  void f(boost::function< void () > a) const {}
};
int main() {
  A a;
  B b;
  b.f(a);
}

lenzo@… — Sat, 18 Jul 2009 10:37:40 GMT

Replying to steven_watanabe:

Any type can be converted to a boost::function. The declaration of the conversion always exists, which is all that the compiler checks for in overload resolution. The conversion doesn't compile unless the type has a function call operator.

That is a pity. Then I guess there is no way to make it work.

I think that this can be considered a bug. Or what else can I do in this case?

Did you really intend to make the overload for A const and the overload for boost::function non-const?

Indeed, that is what I wanted. Probably I should introduce the actual application: I'm having a (self-written) container class "Set", which provides internal iterators, i.e. a method "foreach", which is overloaded in several ways. Here, T is the type of the contained objects.

class Set {
  virtual foreach(boost:function< void (T) >);
  virtual foreach(boost:function< void (const T) >) const ;
  virtual foreach(Computer);
  virtual foreach(ConstComputer) const;
}

where Computer and ConstComputer are defined as follows:

class Computer {
  virtual void prepare();
  virtual void apply(T);
  virtual void finalize();
}
class ConstComputer {
  virtual void prepare();
  virtual void apply(const T);
  virtual void finalize();
}

The idea is that it is possible to use foreach with an arbitrary function, or with an object of type "Computer", which provides the methods prepare() and finalize() to be called before and after the loop. To be able to loop over a constant container of constant objects, it would be nice to be able to use a ConstComputer. Unfortunately, this is where the code fails. Also, it looks as though there is no way round it other than to use two functions. Or is there?

Best regards

Olaf

Steven Watanabe — Sat, 18 Jul 2009 15:53:39 GMT

Then the easiest solution is to add

void foreach(ConstComputer& c) {
    return(static_cast<const Set*>(this)->foreach(c));
}

lenzo@… — Tue, 21 Jul 2009 11:43:09 GMT

Ok, yes, this seems to work. Thanks for the hint.

I'm not exactly sure what to do about this ticket now. It seems to be not exactly a bug in boost.function, but more of a generic C++ problem. Is it even a problem in the C++ standard? I mean, it is surely not a Good Thing (tm) if C++-code does not compile even though there would be a perfectly valid solution, only because the compiler cannot identify it.

I must, however, admit, that I am currently not able to pinpoint the precise problem: why does the compiler first think that there is a conversion from any object to a boost.function object, and only later notice that it cannot call the object?

Do you have any suggestions how to proceed? Or shall we just close this issue as invalid or wontfix?

status changed; resolution set

Steven Watanabe — Fri, 21 Aug 2009 21:15:12 GMT

status new → closed
resolution → invalid

Replying to lenzo@…:

I must, however, admit, that I am currently not able to pinpoint the precise problem: why does the compiler first think that there is a conversion from any object to a boost.function object, and only later notice that it cannot call the object?

That's just the way C++ works. The compiler only checks the declaration (which is correct), not the definition.