🚀 go-pugleaf

Steve Clamage wrote:
> 
> In article 3438@cs.tu-berlin.de, Roman Lechtchinsky
> <wolfro@cs.tu-berlin.de> writes:
> >
> >I have a question about conversion operators and constructors. Consider the
> >following:
> >
> >class X
> >{
> >       X( Y );
> >};
> >
> >class Y
> >{
> >       operator X();
> >};
> 
> A constructor taking a single argument is a type conversion operator from
> the argument type to the class type. The arrangement you show is always
> going to lead to ambiguity errors. There are two ways to convert a Y
> to an X, and neither is preferred over the other. Operator conversion
> functions should normally be avoided, partly for this reason, and partly
> because they can wind up being used in surprising circumstances. The
> compiler might find a conversion that allows erroneous code to compile.
> 
> >Now the second one:
> >
> >class A
> >{
> >               A(B);
> >};
> >
> >class B
> >{
> >               operator A&();
> >};
> 
> This is the same situation. There is no syntactic difference between
> using a reference or an object. Once again, there are two ways to
> make an A out of a B, and neither is preferred.
> 

First of all, sorry: there is a mistake in the example, the constructor 
should be A(B&). However, it doesn't matter since both cases are only a 
variation of the following problem:

The DWP defines:

A constructor declared without the  function-specifier  explicit  that
  can  be called with a single parameter specifies a conversion from the
  type of its first parameter to the type of its  class. [class.conv.ctor]

Now, to me this means that a copy constructor is a converting constructor 
since it takes a single parameter which is a reference to an object of the 
class ( I don't think that this is intended ). If this is true a copy 
constructor is a user-defined conversion ( after all, A and A& are different 
types, aren't they ). This implies that the following call to foo:

foo(b)

is ill-formed ( not ambiguous ) since it requires either b=>B(b)=>A(B(b)) or 
b=>A&(b)=>A(A&(b)) but only one user-defined conversion may be applied ( note 
that foo is defined as foo(A), not foo(A&) ). 


Bye

Roman
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu         ]
[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]
[ Comments? mailto:std-c++-request@ncar.ucar.edu                             ]