Re: [boost] C++ millenium challenge solved?

From: Thorsten Ottosen (tottosen_at_[hidden])
Date: 2005-12-18 09:04:03

Eric Niebler wrote:
> Thorsten Ottosen wrote:

> I noticed this too, and decided it was a bug in gcc. I think that given
> 
>    template<typename T> struct conv {
>        operator T() { return T(); }
>    };
>    template<typename T> void bar(T&) {}
> 
> the expression:
> 
>    typedef foo const cfoo;
>    bar(true ? conv<foo>() : cfoo());
> 
> should compile,

Even though bar takes a T& and not const T& parameter?

> and that in bar, T should be deduced at "foo const". 
> With gcc, it does *not* compile because the expression "true ? 
> conv<foo>() : cfoo()" appears to have the type "rvalue of foo" instead 
> of "rvalue of foo const". gcc is inadvertantly dropping cv-modifiers 
> where it shouldn't.
> 
> But we're certainly free to use that to our advantage. :-)

sure.

> If we can make this work on the popular compilers, it'll be a big win 
> for both boost.foreach and boost.typeof. It doesn't matter if we need to 
> take advantage of compiler bugs to get it. I wonder if other compilers 
> and other versions of gcc accept either my variant or yours.

Good question.

It seems to me that conversion operators are a poorly understood part of 
the language. Maybe you should take this up on the reflector.

Another thing I find wierd is that this seems to lead to ambiguity:

template< class T >
struct probe
{
   operator T&();
   operator T();
};

int main()
{
        int  i = probe<int>(); // error
        int& r = probe<int>(); // ok
}

If I add const to the T() conversion, it suddenly works ok again.

-Thorsten