* Arvid Requate:

I'd like to understand why the following code does not compile.
[snip]

//------------------------complex_double_conversion.cpp-------------------------

#include<complex>

class B {

double v;

public:

operator double() const { return v; } // conversion operator

B(double _v) : v(_v) {}

};

int main() {

std::complex<double> z(0,1);

B x(0.5);

// next line works due to complex<_Tp>&

complex<_Tp>::operator*=(const _Tp&)

// the conversion operator of class B is used

z*=x;

// the next line does not compile

std::complex<double> y( z*x );

// only with cast: z*((double) x)

//

// although in <complex> there is

// template<typename _Tp>

// inline complex<_Tp> operator*(const complex<_Tp>& __x, const

_Tp& __y)

// { return complex<_Tp> (__x) *= __y; }

//

return 0;

}

//-----------------------------------------------------------------------------------------

Template parameter matching does not consider user-defined conversions:

in general types must match exactly (sort of, there's a bit of looseness

in cv-qualification and reference types and so on).

Consider:

template< typename T >

struct Complex { Complex( T = 0, T = 0 ) {} };

template< typename T >

Complex<T> operator*( Complex<T> const&, Complex<T> const& )

{ return Complex<T>(); }

class B

{

double v;

public:

B( double _v ) : v( _v ) {}

operator Complex<double> () const { return v; }

};

int main()

{

Complex<double> z(0,1);

B x(0.5);

// The next line does not compile, not exact match:

z*x;

}

However, adding

template< typename T >

Complex<T> operator*( Complex<T> const& a, B const& b )

{ return a*Complex<T>(b); }

provides an exact match and the code compiles.

A bit more general, adding instead

template< template<class> class C, typename T >

C<T> operator*( C<T> const& a, B const& b )

{ return a*C<T>(b); }

also provides an exact match and the code compiles.

I tried this fix with your original code and it compiles with MSVC 7.1.

However, you'll probably also have to support the opposite argument

order, and other operators such as '+'.

--

A: Because it messes up the order in which people normally read text.

Q: Why is it such a bad thing?

A: Top-posting.

Q: What is the most annoying thing on usenet and in e-mail?