Re: operator overload question
Olli wrote:
1>c:\programme\microsoft visual studio 8\vc\include\xutility(256) :
error C2666: 'eoScalarFitness<ScalarType,Compare>::operator <' : 2
overloads have similar conversions
In some code it finds a use of the less-than operator where it could use
both the builtin one for double values and the one for eoScalarFitness.
What I wonder is what code that is, as it might lie in the call and not the
code that actually causes the error.
template<class _Ty1, class _Ty2> inline
bool __CLRCALL_OR_CDECL _Debug_lt(
const _Ty1& _Left, _Ty2& _Right,
^^^^^^^^^^^^^
const wchar_t *_Where, unsigned int _Line)
The above marked part seems strange to me, I would have expected the call to
use a const reference instead. Not sure if that changes anything.
template <class ScalarType, class Compare >
class eoScalarFitness
{
public :
eoScalarFitness() : value() {}
eoScalarFitness(const eoScalarFitness& other) : value(other.value) {}
eoScalarFitness(const ScalarType& v) : value(v) {}
This ctor should be explicit, I think....
eoScalarFitness& operator=(const eoScalarFitness& other)
{ value = other.value; return *this; }
eoScalarFitness& operator=(const ScalarType& v)
{ value = v; return *this; }
operator ScalarType(void) const { return value; }
.... and this conversion should be explicit, too. Unfortunately C++ doesn't
recognize (yet) the 'explicit' keyword in conversion operators, so you
should instead use a get() function or somesuch. I guess that that is also
the problem: if you try to compare this object with an object of the
ScalarType, it could either use the non-explicit ctor to create another
oeScalarFitness or use the conversion operator to get a ScalarType.
/// Comparison, using less by default
bool operator<( const eoScalarFitness & other) const { return
Compare()(value, other.value); } // THIS IS THE FAULTY? OVERLOAD
The overload itself is not faulty, although I personally would have made it
a free function. That way you can also implement the other two (possibly
necessary) overloads:
wrapper < wrapper // given here as member
wrapper < scalar // missing
scalar < wrapper // missing
scalar < scalar // provided by scalar type
The same of course applies to the other comparison operators (which lack ==
and != for completeness, btw).
If these comments don't help, please provide a minimal(!) example, as is
customary on the Usenet.
Uli