How do I define a class Imaginary???

[firix]

Hi friends,

Define a class Imaginary to represent imaginary numbers. Define class Complex based on that.Implement the fundamental arithmetic operators.

This class Implements Complex Numbers and it's Functions.
I define a class of complex, but I not define a class Imaginary.

class Complex{
	double    r, i;
public:
    Complex(double r_val = 0.0, double i_val = 0.0):r(r_val), i(i_val){}

	Complex(const Complex &g)
	{
		r = g.r;
		i = g.i;
	}

	Complex &operator=(const Complex &g)
	{
		r = g.r;
		i = g.i;
		return *this;
	}

	Complex &operator+=(const Complex &g)
	{
		this->i += g.i;
		this->r += g.r;

		return *this;
	}
	Complex &operator-=(const Complex &g)
	{
		this->i -= g.i;
		this->r -= g.r;

		return *this;

	}
	Complex &operator*=(const Complex &g)
	{
		this->i *= g.i;
		this->r *= g.r;

		return *this;

	}
	
	Complex &operator/=(const Complex &g)
	{
		this->i /= g.i;
		this->r /= g.r;

		return *this;

	}




    void set(double r_val, double i_val)
    {
        r = r_val; i = i_val;
    }

    void get(double &r_val, double &i_val) const
    {
        r_val = r; i_val = i;
    }

	double get_real() const 
	{ 
		return r; 
	}
    double get_imaginary() const 
	{ 
		return i; 
	}

	Complex operator+(const Complex &a)
	{
		return Complex(this->get_real() + a.get_real(),this->get_imaginary() + this->get_imaginary());
	}

	Complex operator-(const Complex &a)
	{
		return Complex(this->get_real() - a.get_real(),this->get_imaginary() - this->get_imaginary());
	}

		Complex operator*(const Complex &a)
	{
		return Complex(this->get_real() * a.get_real(),this->get_imaginary() * this->get_imaginary());
	}

	Complex operator/(const Complex &a)
	{
		return Complex(this->get_real() / a.get_real(),this->get_imaginary() / this->get_imaginary());
	}


 friend bool operator==(const Complex &r1, const Complex  &r2);
 friend bool operator!=(const Complex &r1, const Complex  &r2);
 friend bool operator<(const Complex &r1, const Complex  &r2);
 friend bool operator>(const Complex &r1, const Complex  &r2);
 friend bool operator<=(const Complex &r1, const Complex  &r2);
 friend bool operator>=(const Complex &r1, const Complex  &r2);

 friend istream &operator>>(istream &is, Complex &value);



};




bool operator==(const Complex &r1, const Complex  &r2)
{
	if (r1.i ==  r2.i &&  r1.r == r2.r)
		return true;
	else 
		return false;

}
bool operator!=(const Complex &r1, const Complex  &r2)
{
	if (r1.i !=  r2.i &&  r1.r != r2.r)
		return true;
	else 
		return false;


}
bool operator<(const Complex &r1, const Complex  &r2)
{
	
	if (r1.i <  r2.i && r1.r < r2.r)
		return true;
	else 
		return false;

}
bool operator>(const Complex &r1, const Complex  &r2)
{
	
	if (r1.i >  r2.i &&  r1.r > r2.r)
		return true;
	else 
		return false;


}
bool operator<=(const Complex &r1, const Complex  &r2)
{
	
	if (r1.i <=  r2.i &&  r1.r <= r2.r)
		return true;
	else 
		return false;


}
bool operator>=(const Complex &r1, const Complex  &r2)
{
	
	if (r1.i >=  r2.i &&  r1.r >= r2.r)
		return true;
	else 
		return false;


}


ostream &operator<<(ostream &os, const Complex &value)
{
	os << '<' << value.get_real() << ',' << value.get_imaginary() << '>';
    return os;


}

istream &operator>>(istream &is, Complex &value)
{
	return is >> value.i >> value.r;
}

How do I define a class Imaginary?

[hamsterman]

I suppose you could create a class to represent the imaginary part. Though of course, it would be a useless wrapper around a double.
Just ask your teacher..

[firix]

what is teacher?
I got this question in the book of Bjarne Stroustrup?

"Define a class Imaginary to represent imaginary numbers. Define class Complex based on that. Implement the fundamental arithmetic operators"

[hamsterman]

Fine. If you want, write a class Imaginary and overload the +-*/ operators (I assume you know how). Then in class Complex, change member i from double, to Imaginary, and change the code you already wrote to use its operators.

[firix]

@hamsterman

Can you show the code?

[hamsterman]

...

class Imaginary{
   double i;
   Imaginary oparator + (const Imaginary& b) {/*...*/}//write them yourself
   Imaginary oparator - (const Imaginary& b) {/*...*/}
   double oparator * (const Imaginary& b) { return -1*i*b.i; }
   double oparator / (const Imaginary& b) {/*...*/}
   //you probably also want to write the same operators for doubles
};

class Complex{
   double a;
   Imaginary b;
   Complex(/*...*/){/*...*/}
   Complex operator + (const Complex& c){ return Complex(a+c.a, b+c.b); }
   //and so on.
};

By the way, you know, it's a book so no one if forcing you to do that.. If you feel comfortable with operator overloading (which I assume was the key element) then you can move on. That's the power of choice!..

[firix]

thanks hamsterman