Re: Problems with PR 21210

[Mark Mitchell <mark at codesourcery dot com>]

Paolo Carlini wrote:
> Mark Mitchell wrote:
>
>
> > 1. Overload resolution
> >
> >  void f(std::complex<double>);
> >  void f(__complex__ double);
> >
> >  double d;
> >  ... f(d) ...
> >
> > which f should get called?  Under the semantics I used (conversion
> > from double to __complex__ double is a standard conversion) we'd pick
> > the second "f".  I'd say either we should use the second "f", which
> > seems right to me; the other plausible choice would be to consider the
> > call ambiguous.
>
>
> I must be missing something, either technical about the language itself
> or about the present discussion: I don't see how would be correct
> picking the second 'f'; ambiguity seems also wrong. My reasoning is
> that, according to the current C++ standard, we have a constructor from
> a pair of doubles, each one *with a default*: the first f, by itself
> certainly works. Then, we add a *non-standard* constructor, from
> __complex__ double, and... boomer! it gets *preferred*!?! Please explain
> in better detail.

We're not talking about which constructors for std::complex is used 
anymore; we're talking about which "f" you call.  (We left the standard 
behind when we declared the second "f"; this is no longer an ISO C++ 
program.)

The same puzzle would apply even if you had a library where std::complex 
didn't have a constructor from "__complex__".  In other words, just 
think about the question I asked like this:

  struct S {
    S(double);
  };

  void f(S);
  void f(__complex__ double);

  double d;
  ... f(d) ...

Which "f" should we call?

The conversion to "S" requires a constructor call, which is usually 
considered worse than a "standard conversion" (like converting from 
"int" to "double").  So, that's why I think we should call the second "f".

--
Mark Mitchell
CodeSourcery, LLC
mark@codesourcery.com
(916) 791-8304