Problem understanding Inheritance

[phy2j2s]

Hello again,

I working through the book C++ without Fear (2nd Ed), and have become stuck on Exercise 17.2.1.

The problem is as follows,

In previous chapters a 'Fraction' class was derived that gave the ability to store fractions - you entered in a Numerator (N) and Denominator (D) and the fraction with the lowest common denominator was stored inside the class.

The values for N and D were stored in int format.

To demonstrate inheritance, a new class called FloatFraction is derived from the Fraction class, whereby it is possible to turn a float into a fraction (eg. 2.2 = 11/5).

In the original Fraction class it was possible to add two fractions together using a 'Fraction operator+(const Fraction &other)' function (eg. 1/4 + 1/4 = 1/2)

The exercise is to extend this ability to add together two FloatFractions.

I've spent quite a while trying but this task seems beyond me. I've included the full code below (although I've removed some of the non-necessary functions to save space, and the Fraction class is declared in the same code, whereby before it was in a separate file).

Adding a FloatFraction and a Fraction to yield a new Fraction is possible

 	FloatFraction floatfract1(2.2), floatfract2;
	Fraction fract1(1,1), fract2;

	fract2 = floatfract1 + fract1;
	
	cout << fract2;

prints 16/5 as expected.

But when attempting to add a FloatFraction and a Fraction to yield a new FloatFraction

  	FloatFraction floatfract1(2.2), floatfract2;
	Fraction fract1(1,1), fract2;

	floatfract2 = floatfract1 + fract1;
	
	cout << fract2;

gives the following error

error: no match for 'operator=' in 'floatfract2 = Fraction::operator+(const Fraction&)(((const Fraction&)((const Fraction*)(& fract1))))'

Thanks for your help

FULL CODE:

#include <iostream>
//#include "Fract.h"

#include <iostream>

using namespace std;


// ==================================
class Fraction {
private:
	int num, den; // Numerator and denominator.

public:
		
	Fraction() {set(0, 1);}
	Fraction(int n, int d) {set(n, d);}
	Fraction(int n) {set(n, 1);}
	Fraction(const Fraction &src);
	void set(int n, int d)
	{num = n; den = d; normalize();}
	int get_num() const {return num;}
	int get_den() const {return den;}
	Fraction add(const Fraction &other);
	
	Fraction operator+(const Fraction &other)
	{return add(other);}
	
	friend ostream &operator<<(ostream &os, Fraction &fr);
private:
	void normalize(); // Convert to standard form.
	int gcf(int a, int b); // Greatest Common Factor.
	int lcm(int a, int b); // Lowest Common Denom.
};
//=============================================


// Note: Fract.cpp must be compiled and linked into
// the project.
class FloatFraction : public Fraction {
public:
	FloatFraction(double n){set_float(n, 1);}
	
	void set_float(double dn, double dd);
	
	FloatFraction() {set(0, 1);}
	FloatFraction(int n, int d) {set(n, d);}
	FloatFraction(int n) {set(n, 1);}
	FloatFraction(const FloatFraction &src)
	{set(src.get_num(), src.get_den()); }
	
	double get_float() {
		double x = get_num();
		return x / get_den();
	}
	
};
int main() {
		
	FloatFraction floatfract1(2.2), floatfract2;
	Fraction fract1(1,1), fract2;

	floatfract2 = floatfract1 + fract1;
	
	cout << fract2;	
	

	return 0;
}


void FloatFraction::set_float(double dn, double dd){
	int n, d;
	n = static_cast<int> (dn * 1000);
	d = static_cast<int> (dd * 1000);
	//	cout << "Setting: " << n << " / " << d << endl;
	
	set(n, d);
}


//===========================================
Fraction::Fraction(Fraction const &src) {
	num = src.num;
	den = src.den;
}
// Normalize: put fraction into standard form, unique
// for each mathematically different value.
//
void Fraction::normalize(){
	// Handle cases involving 0
	if (den == 0 || num == 0) {
		num = 0;
		den = 1;
	}
	// Put neg. sign in numerator only.
	if (den < 0) {
		num *= -1;
		den *= -1;
	}
	// Factor out GCF from numerator and denominator.
	int n = gcf(num, den);
	num = num / n;
	den = den / n;
}
// Greatest Common Factor
//
int Fraction::gcf(int a, int b){
	if (b == 0)
		return abs(a);
	else
		return gcf(b, a%b);
}

// Lowest Common Multiple
//
int Fraction::lcm(int a, int b){
	int n = gcf(a, b);
	return a / n * b;
}
Fraction Fraction::add(const Fraction &other) {
	int lcd = lcm(den, other.den);
	int quot1 = lcd/den;
	int quot2 = lcd/other.den;
	return Fraction(num * quot1 + other.num * quot2,
					lcd);
}
/*Fraction Fraction::add(const Fraction &other) {
 int lcd = lcm(get_den(), other.get_den());
 int quot1 = lcd/get_den();
 int quot2 = lcd/other.get_den();
 return Fraction(get_num() * quot1 + other.get_num() * quot2,
 lcd);
 }*/


// ---------------------------------------------------
// FRACTION CLASS FRIEND FUNCTION
ostream &operator<<(ostream &os, Fraction &fr) {
	os << fr.num << "/" << fr.den;
	return os;
}

//=================================================

[benedictusk]

But when attempting to add a FloatFraction and a Fraction to yield a new FloatFraction

I think your mistake is trying to do this. FloatFraction expects a float, but you are assigning it the sum of two fractions (which turns out to be a fraction).

[andywestken]

You need to define more operators!

Can you add two FloatFractions? I don't see a definition for operator+ in FloatFractions.

[phy2j2s]

Oh! I've fixed it so I can now add two FloatFractions by adding an operator+ in the FloatFraction class.

However is there no way to inherit this ability from the original Fraction class without having to create a new operator + in the FloatFraction class? As I thought this was the purpose of the exercise?

Thanks

[anonymous23323124]

Well think about it. If anything, it inherits the function:
Fraction operator+(const Fraction &other)
(i.e. it adds a Fraction to a FloatFraction).

That function isn't what you want. You need
FloatFraction operator+(const FloatFraction& other)
(adds two FloatFractions).

I may be wrong, but I think this describes the situation.

[Sythion]

You were inheriting the + operator action from the fraction class. The problem is it wasn't designed to work with FloatFunctions, which it doesn't even know exist at the time of the + operator definition.

I believe you could forward declare the FloatFraction class and inherit the ability you want as well, like this:

class FloatFraction;
FloatFractionoperator+(const FloatFraction&other)
{return add(other);}

but that's probably not the point of the excercise ;)
(also my syntax might be off. I'm learning c++ myself.)

[andywestken]

Sorry!

Just checked my copy of Stroustrup.

It all works for me if I add an additional constructor to FloatFraction

FloatFraction(const Fraction &src)
{set(src.get_num(), src.get_den()); }

No need for operator+ to re-declared here as there are no new data members added to FloatFraction. It safely inherited in this case.

These tests all behave OK

	{
		FloatFraction fract1(1, 2);
		Fraction fract2(1, 4);
		Fraction fract3 = fract1 + fract2;
		cout << fract3 << endl;
	}

	{
		FloatFraction fract1(0.5);
		FloatFraction fract2(0.25);
		Fraction fract3 = fract1 + fract2;
		cout << fract3 << endl;
	}

	{
		FloatFraction fract1(0.5);
		Fraction fract2(1, 4);
		FloatFraction fract3 = fract1 + fract2;
		cout << fract3 << endl;
	}

	{
		Fraction fract1(1, 4);
		FloatFraction fract2(0.5);
		FloatFraction fract3;
		fract3 = fract1 + fract2;
		cout << fract3 << endl;
	}

3/4
3/4
3/4
3/4

They all work OK if fract3 is declared as a Fraction, too.

Notes
1 - it is usual to declare operator= when you declare a copy constructor
2 - operator= is not inherited by derived classes (Stroustrup, C++ Prog Lang)

[phy2j2s]

Thank-you very much, that works just fine now.