'operator <<' is ambiguous

You have the following constructor which is causing the problem:

class Fraction {
   public:
       Fraction( float f );
};

To fix this:

class Fraction {
   public:
       explicit Fraction( float f );
};

add the keyword explicit. This may break other code. Specifically, if you are relying on the compiler
to perform implicit conversion of floats to Fractions (via the above constructor), this will no longer
happen, and you need to make it explicit:

// This would stop compiling:
Fraction f = 0.25;

// This is correct:
Fraction f( 0.25 );

Watch your consts in your argument lists. See lines 7 and 48.

ty duoas for reminding me of my mistake...

jsmith: i dont quite understand what i have to do, ive just added explict before custom constructor, but nothing changes

I didn't realize there was a class working with fraction classes until just today...

Mathematically, a fraction is composed of an integer numerator and an integer denominator. You should not have a constructor of the form
Fraction( float f )
(unless, of course, your professor wants otherwise... but it is still a bad idea).

If you must perform conversions from float to Fraction via assignment and the like, then use an explicit constructor like jsmith indicated... this will prevent the compiler from taking too many liberties when it shouldn't. (Remember, a fraction is not a float.) Converting a float to a fraction is not a particularly simple thing to do. (But it can be done, mind you.)

Hopefully you have a constructor something like:
Fraction( int numerator = 0, int denominator = 1 )
This gives you a default constructor, an int to Fraction constructor, and a proper fraction constructor.

I/O operators
(In C++, that's the extraction and insertion operators.)
The purpose of the operator is to allow you to read or write your data to any stream -- the same one given as argument (in your case, that's is and os -- BTW, a word like "is" is not a good name for a variable; I tend to use unambiguous names like "ins" and "outs" for in-stream and out-stream respectively).

However, your operators not only completely ignore the argument streams, but they invoke other streams to perform their task. Worse than that -- the input operator (the 'extract from stream' operator) performs output. That's bad.

The I/O operators should expect input based upon a specific format. For example, you may say that a fraction, when written, must always have the form:
['-'] digits '/' digits
This makes I/O easy -- in fact, it is the natural way we write fractions. Your program might then run:
Enter a fraction: -2/5 You entered -2/5 which is the same as -0.4.
The extraction (input) operator should read the "-2/5" directly. It should not expose the user to the details of how the class is implemented ("Yoinks! That is a numerator and a denominator in there!")

Doing input is typically a bit more difficult than output. You will need to do some error checking on the "/" character of the input. I recommend you use peek() and setstate(). For example:

istream& operator >> ( istream& ins, Fraction& frac )
{
	// stuff to read the numerator goes here
	...

	// read the "/" and complain if it isn't
	int c = ins.peek();
	if (c != '/')
	{
		ins.setstate( ios::failbit );
		return ins;
	}

	// stuff to read the denominator goes here
	...

	// return the current stream for the next input operator
	return ins;
}

Notice how cin and cout are not involved anywhere inside the extraction operator function. The code that uses the extraction operator does stuff like:

1
2
3

	Fraction f;
	cout << "Please enter a fraction: " << flush;
	cin >> f;

Output is considerably easier. Just check to make sure your denominator isn't negative before writing things out. You will have to think about how to turn a fraction like:
3 --- -4
into something that prints like "-3/4". Remember, your insertion (output) operator should not modify the object:
ostream& operator << ( ostream& outs, const Fraction& frac )

Well, lunch is calling, so that's all I'm going to say for now.
You might want to point other confused classmates to this post.

Hope this helps.

first of all this is not a school assignment

ok ive seen that i made a major mistake, because i used a float type in << operators parameter (which does not make sence, since float can be outputed in a normal way)

but as it looks it can be used in this way aswell, since youve tought i meant it like that

so heres the modified (main.cpp) code:

#include <iostream>
#include "Fraction.h"
using namespace std;


std::istream& operator>>(std::istream& is, Fraction& rho);
std::ostream& operator<<(std::ostream& os, Fraction& rho);

int main()
{
	Fraction frac;
	cin >> frac;

	Fraction frac1;
	cin >> frac1;

    /*cout << "Chose operation between the two fractions: " << endl;
	cout << "1.+, 2.-, 3.*, 4./, 5.==, 6.!=, 7.>=, 8.<=; 9.quit" << endl;
	char num = 0;
	cin >> num;

	float operation = 0;
	switch(num)
	{
	case 1:
		operation = frac + frac1;
		cout << "Result is: " << operation << endl;
		break;
	}

	cout << "Result is: " << operation << endl;*/

	float a = frac + frac1;
	cout << a;





}

std::istream& operator>>(std::istream& is, Fraction& rho)
{
	cout << "Enter numerator: ";
	cin >> rho.numerator;
	cout << "Enter denominator: ";
	cin >> rho.denominator;

	return is;
}
	
std::ostream& operator<<(std::ostream& os, Fraction& rho)
{
	//cout << rho.numerator << "/" << rho.denominator;
	cout << (float)rho;

	return os;
}

but now the problem is the following:
- if i use those those lines inside /*...*/, i "always" get 0 as a result, but if i use the two lines
(that are in bold) instead of those, i get the correct result

What seems to be the problem?

you mean

case '1':

the code inside case 1 is never executing, which I believe you knew, because you wouldn't see
the "Result is:" output that it does, but you have the same output after the switch.

yea ive finished the program already and now trying to make, so that user can inpu "2/3", and not numerator and denominator seperate....

but in this particular place, i just used int instead of char - why cant i use char?

and why if i use const in ostream (or ostream), i get:
error C2679: binary '<<' : no operator found which takes a right-hand operand of type 'const float' (or there is no acceptable conversion)
(just wondering)

Last edited on

If the user types (without the quotes): "1 <ENTER>"

...and you read into an int, the int value is 1.
...and you read into a char, the char value is '1' (ASCII 0x31, decimal 49)

You do not need to write operator<< for const float (original post, line 7).
Otherwise, you'll need to post your code along with the exact compile error (and line num).

Duoas: can you please tell me how i should implement peek() and setstate() in my code, so that i could input fractions in a normal way? what i did is just this:

std::istream& operator>>(std::istream& is, Fraction& rho)
{
	cout << "Enter fraction: ";
	cin >> rho.numerator;

	char c = is.peek();
	if (c != '/')
	{
		is.setstate( ios::failbit );
		return is;
	}

	cin >> rho.denominator;  // i know i shoul use cin only once, if i want to inpust in this way:  
                                                // "2/3"
	return is;
}

Last edited on

You are getting much closer.

You shouldn't use cin at all -- the caller of the function handed you the proper object to use: is (which, BTW, I think is not a good name; use "ins" or "inputstream" or somesuch instead).

Also, you should not be using cout either.

Hope this helps.

ok ithink what u meant is that in the operators definitions (in >> and <<), the specified object ofistream that ive made, is now actually the object, which represents cin and cout member definitions of that class, and that i should use this instead of "cin >>" and "cout <<" (because im obviously overloading that operator) - which i did

- how do i implement this:
"// stuff to read the numerator/denominator goes here" ?

Last edited on

ok, i have done the input part in some other, more easy way and im almost at the end

anyway, now im asking if there is a way of using more then 1 character for input, in a way so that it can be put in a switch statement as a case label? (or ill just have to use if statements?)
with +,/,-,* - which are singel characters theres no problem, but with relational operators - ==, !=, >=, <=, there is!

ty in advance

Last edited on

Unfortunately for strings, switch-case is not viable. You'll have to use if-else.

(Alternatively, but this is more advanced, you could create a map of strings to function pointers, look up the string in the map and call the associated function. This gives you very similar behavior to switch statements at the cost of having to build the map.)

you have to use #include <map> right?

can you demonstrate how i could do this in my case (for: ==,!=,>=,<=), if thats ok with you

Last edited on

Here's one simple example of how to select on a string. (See the very last post on the page.)
http://www.cplusplus.com/forum/general/11460/

can i mix ordinary cin with getline - because if i do, i cant input normally (i think it skips the getline part...):

	cin >> frac;

	getline(cin, operation);

	cin >> frac1;

No. You must clear the newline (and any other extraneous characters left on the line) after using operator >>.

#include <iostream>
#include <limits>
#include <string>
using namespace std;

int main()
  {
  double age, favorite_number;
  string name;

  // User enters his age
  cout << "What is your age? " << flush;
  cin >> age;
  cin.ignore( numeric_limits <streamsize> ::max(), '\n' );

  // User enters his name
  cout << "What is your name? " << flush;
  getline( cin, name );

  // User enters his favorite number
  cout << "What is your favorite number? "  << flush;
  cin >> favorite_number;
  cin.ignore( numeric_limits <streamsize> ::max(), '\n' );

  // User gets thrown off bridge...
  cout << "Aaaaiiiieeeeee!\n";
  return 0;
  }

The user expects the press the Enter key after every input.

Some inputs are more complicated than above. For example, inputting an equation is more complex:
12.9 / (3.47 + 2)
The entire input is one line, but you must parse the individual items on the line (numbers, operators, parentheses, etc.)

Hope this helps.

Last edited on

nothing changes...

        cin >> frac;
	cin.ignore( numeric_limits <streamsize> ::max(), '\n' );

	getline(cin, operation);

	cin >> frac1;
	cin.ignore( numeric_limits <streamsize> ::max(), '\n' );

what happens is same as before - if i input 67/56 + 676/65, it wants another two inputs (what youve said)