Starx wrote:

I was wondering if someone could help me get around this problem I'm

having. I'm writing a fraction class and would like to overload the

binary arithmetic operators so that when any numerical data type (int,

double, long double, etc.) is used with a fraction it is first

converted to a fraction and then added, the result being a fraction.

So I started with this:

template <class numericType>

friend fraction operator +(const fraction& lhs, const numericType&

rhs);

template <>

friend fraction operator +(const fraction& lhs, const fraction& rhs);

The first function was simply:

{ return lhs + fraction(rhs); }

The second function was a template specialization that did the math

when adding two fractions. This worked great, as long as a fraction

was the first argument I could add it with any other data type that I

had a constructor for. But I also want addition to be commutative so

that "fraction + int" and "int + fraction" do the same thing. To get

that I added this function:

template <class numericType>

friend fraction operator +(const numericType& lhs, const fraction&

rhs);

Which did the same thing as the other function, converted explicitly to

a fraction and then added, relying on the template specialization to

add fractions. But now I get this error:

error C2667: '+' : none of 2 overload have a best conversion

How can I get rid of this? I just want it so that given:

fraction x, y;

int z;

these statements are valid and error free:

x + y;

x + z;

z + x;

I'm running VC++ 6.0

If class 'fraction' has constructors for each of the

required numeric types (fraction(int), fraction(long),

fraction(double), etc), then you should only need one

friend operator+() method that takes 2 'fraction'

objects. If a numeric is specified on either side

of the "+" (z + x, or x + z), the compiler should

apply the correct conversion constructor before

invoking the operator+().

Here's an example:

#include <iostream>

// a dummy 'fraction' class for experimental purposes

class fraction

{

public:

fraction() : vd(0) {}

fraction(const int v) : vd(v) {}

fraction(const long v) : vd(v) {}

fraction(const double v) : vd(v) {}

fraction operator=(const fraction& oth)

{ vd = oth.vd; vi = oth.vi; }

friend fraction operator+(const fraction& rhs, const fraction& lhs);

int vi;

double vd;

};

fraction operator+(const fraction& rhs, const fraction& lhs)

{ return fraction(rhs.vd + lhs.vd); }

int main()

{

fraction fx(25.34), fy(30), fr;

int iz = 66;

long lz = 530;

std::cout << "fx = " << fx.vd << ", "

<< "fy = " << fy.vd << ", "

<< "iz = " << iz << ", "

<< "lz = " << lz << std::endl;

fr = fx + fy;

std::cout << "fx + fy = " << fr.vd << std::endl;

fr = fx + iz; // 'iz' is converted to a 'fraction'

std::cout << "fx + iz = " << fr.vd << std::endl;

fr = iz + fx; // 'iz' is converted to a 'fraction'

std::cout << "iz + fx = " << fr.vd << std::endl;

fr = lz + fx; // 'lz' is converted to a 'fraction'

std::cout << "lz + fx = " << fr.vd << std::endl;

fr = 99 + fy; // 99 is converted to a fraction

std::cout << "99 + fy = " << fr.vd << std::endl;

fr = fy + 99; // 99 is converted to a fraction

std::cout << "fy + 99 = " << fr.vd << std::endl;

return 0;

}

Regards,

Larry