Boost logo

Boost :

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. :-)


> 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.


Boost list run by bdawes at, gregod at, cpdaniel at, john at