Constructor Conversion

[chaturchand]

Hi There,



following is my main(). Requirement is Rational a=1 assignement should work but Rational a=1.2 shouldnt. Copiler should error when compliling Rational a=1.2. I tried overloading = operator using following function but it also allows Rational a=1.2 go through with truncation, which i dont want. Please help

void operator=(int n)
{
Rational(n,1)
}

Let me know if you need more details.

main()
{
Rational a=1;
Rational a=1.2

}

//rational.h
#include<iostream>

class Rational
{
private:
    // Private functions
    void Normalize(); // To be implemented in the rational.cpp file
	int  m_num;    // numerator
    int  m_den;    // denominator  

	Rational( double n,double d)
	{
	}

public:

  Rational operator-();
  Rational operator+();

  friend Rational operator+(Rational,Rational);
  friend double operator+(double,Rational);
  friend double operator+(Rational,double);

  friend Rational operator-(Rational,Rational);
  friend double operator-(Rational,double);
  friend double operator-(double, Rational);
  
  friend Rational operator*(Rational,Rational);
  friend double operator*(Rational,double);
  friend double operator*(double,Rational);

  friend Rational operator/(Rational,Rational);
  friend double operator/(double,Rational);
  friend double operator/(Rational,double);
  
    
 explicit Rational (const int n=0,const int d=1)
	  {
       m_num=n;
	   m_den=d;
	   Normalize();
	  }
Rational (int &n);



operator double()
{
return double(m_num)/double(m_den);
}
     
void Print();   // Implemented in the rational.cpp file

// Access member functions
int Numerator()     { return m_num; }
int Denominator()   { return m_den; }
  
};

 



// rational.cpp

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

void Rational::Print()
{
	if (m_num/m_den < 0)
	{
		std:: cout << '-';
	}
	Normalize();
	std:: cout << '(' << m_num 
		     << '/' << m_den << ')'
		     << std:: endl;
}

Rational Rational::operator-() // unary minus overloading
   {
	  /*Rational unminus;
	  unminus.m_num=(-r1.m_num);
	  unminus.m_den=(-r1.m_den);	
	  unminus.Normalize ();
	  return unminus;*/
	   return Rational(-(this->Numerator()), this->Denominator());
   }
Rational Rational::operator+() // unary Plus overloading
   {
	  /*Rational unplus;
	  unplus.m_num=(r1.m_num);
	  unplus.m_den=(r1.m_den);	
	  unplus.Normalize ();
	  return unplus;*/
	   return *this;
   }
Rational operator+(Rational r1, Rational r2) // Rational + Rational
{
Rational ratplus;
ratplus.m_num =(r1.m_num)*(r2.m_den)+ (r2.m_num)*(r1.m_den);
ratplus.m_den =(r2.m_den)*(r1.m_den) ;
ratplus.Normalize ();
return ratplus;
}
double operator+(double r1, Rational r2) // double + Rational
{
double ratplus;
ratplus=r2; 
return r1 + ratplus;
}

double operator+(Rational r1, double r2) // Rational + double
{
double ratplus;
ratplus=r1; 
return ratplus + r2;

}
Rational operator-(Rational r1, Rational r2) // Rational - Rational
{
Rational ratplus;
ratplus.m_num =(r1.m_num)*(r2.m_den)-(r2.m_num)*(r1.m_den);
ratplus.m_den =(r2.m_den)*(r1.m_den) ;
ratplus.Normalize ();
return ratplus;
}
double operator-(double r1, Rational r2) // double - Rational
{
double ratplus;
ratplus=r1-(r2.m_num)/(r2.m_den); 
return ratplus;
}

double operator-(Rational r1, double r2) // Rational - double
{
	double dlhs = r1;
	return dlhs + r2;
}

Rational operator*(Rational r1, Rational r2) // Rational*Rational 
{
Rational ratmult;
ratmult.m_num =r1.m_num * r2.m_num ;
ratmult.m_den =r1.m_den * r2.m_den ;
ratmult.Normalize ();
return ratmult;
}
double operator*(double r1, Rational r2) // double * Rational
{
double ratplus;
ratplus=(r1*r2.m_num)/(r2.m_den); 
return ratplus;
}

double operator*(Rational r1, double r2) // Rational * double
{
double dr1 = r1;
return dr1 * r2;
}


Rational operator/(Rational r1, Rational r2) // Binary division overloading
{
Rational ratdiv;
ratdiv.m_num =(r1.m_num * r2.m_den) ;
ratdiv.m_den =(r1.m_den * r2.m_num );
ratdiv.Normalize ();
return ratdiv;
}

double operator/(double r1, Rational r2) // double / Rational
{
double ratplus;
ratplus=(r1*r2.m_den)/r2.m_den; 
return ratplus;
}

double operator/(Rational r1, double r2) // Rational / double
{
double dr1 = r1;
return dr1/r2;
}



void Rational::Normalize()           // Normalize() defination
{

    if ( (m_num == 0) || (m_den == 0) )
        int a=1;

    if (m_num < 0)
        m_num = -m_num;
    if (m_den < 0)
        m_den = -m_den;

    // Euclid's algorithm...
    int a, b, r;

    if (m_den > m_num)
    {
        a = m_den;
        b = m_num;
    }
    else
    {
        a = m_num;
        b = m_den;
    }
    r = 1;
    while (r > 0 && b > 0)
    {
        r = a % b;
        a = b;
        b = r;
    }
    m_num=m_num/a;
	m_den=m_den/a;

}