Question

This is a C++ programming question. Please provide the correct, workable code. Use the following three programs to help solve the problem. Provide comments throughout the code.

Problem to solve:

1. Use the Complex class posted online. Modify the Complex h and Complex.cpp to support operator overloading for the operators +, - *, and / for add, sub, mul, and div operations. Demonstrate overloaded operators in the Application.cpp.

Code 1: Complex.h

#pragma once
#ifndef COMPLEX_H
#define COMPLEX_H
class Complex
{
private:
   double real;
   double imag;
public:
   // initialize the complex number to 0.0
   Complex() : real(0.0), imag(0.0) {}
   // initialize the complex number at declaration or new
   Complex(double r, double i) : real(r), imag(i) {}
   // this is actually the same as the default copy constructor provided by the compiler
   Complex(const Complex &c) : real(c.real), imag(c.imag) {}  

   void setReal(double r) {real = r;}
   void setImag(double i) {imag = i;}
   void setComplex(const Complex &c) {real = c.real; imag = c.imag;}
   double getReal() const {return real;}
   double getImag() const {return imag;}
   Complex getComplex() const {return *this;}

   Complex add(const Complex &) const;
   Complex sub(const Complex &) const;
   Complex mul(const Complex &) const;
   Complex div(const Complex &) const;

   void print() const;
   void print(const Complex &) const;
};

#endif

Code 2: Complex.cpp

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

Complex Complex::add(const Complex &c) const {
   Complex result;
   result.real = real + c.real;
   result.imag = imag + c.imag;
   return result;
}
Complex Complex::sub(const Complex &c) const {
   Complex result;
   result.real = real - c.real;
   result.imag = imag - c.imag;
   return result;
}
Complex Complex::mul(const Complex &c) const {
   Complex result;
   result.real = real * c.real - imag * c.imag;
   result.imag = imag * c.real + real * c.imag;
   return result;
}
Complex Complex::div(const Complex &c) const {
   double t = c.real * c.real + c.imag * c.imag;
   Complex result;
   result.real = (real * c.real + imag * c.imag) / t;
   result.imag = (imag * c.real - real * c.imag) / t;
   return result;
}

void Complex::print() const {
   cout << "( " << real << ", " << imag << " )\n";
}

void Complex::print(const Complex &c) const {
   c.print();
}

Code 3: Application.cpp

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

void main() {
   Complex a(4.0, 6.0), b(3.0, 5.0), *c = new Complex(1.0, 1.0);
   Complex d(a); d.print();
   a.add(b).add(*c).print();
   c->print(a);
}

Answer 1

Screenshot of program code:-

//Complex.h

#pragma once #ifndef COMPLEX_H #define COMPLEX_H class Complex { private: double real; double imag; public: VI initialize the complex number to 0.0 Complex() : real(0.0), imag(0.0) {} \/ initialize the complex number at declaration or new Complex (double r, double i) : real(r), imag(i) {} // this is actually the same as the default copy constructor provided by the compiler Complex(const Complex &c) : real(c.real), imag(c.imag) {} c.imag;} void setReal(double r) {real = r;} void setImag(double i) {imag = i;} void setComplex(const Complex &c) {real = c.real; imag double getReal() const {return real;} double getImag() const {return imag;} Complex getComplex() const {return *this;} //Overloaded functions prototype Complex operator+(const Complex & const; Complex operator-(const Complex &) const; Complex operator* (const Complex & const; Complex operator/(const Complex &) const;

//Print functions prototype void print() const; void print(const Complex & const; }; #endif

//Complex.cpp #include <iostream> using namespace std; #include "Complex.h" //addition(+) operator function overloading Complex Complex::operator+(const Complex &c) const { Complex result; result.real = real + c.real; result.imag - imag + c.imag; return result; ہا // subtraction(-) operator function overloading Complex Complex::operator-(const Complex &c) const { Complex result; result.real real - c.real; result.imag = imag - c.imag; return result; ہا //multiplication(*) operator function overloading Complex Complex:: operator*(const Complex &c) const { Complex result; result.real real * c.real - imag c.imag; result.imag = imag C.real + real c.imag; return result; مها

//division(/) operator function overloading Complex Complex:: operator/(const Complex &c) const { double t = c.real * c.real + c.imag * c.imag; Complex result; result.real = (real (real * c.real + imag * c.imag) / t; result.imag = (imag * c.real - real * c.imag) / t; return result; } //Functions to print the result void Complex::print() const { cout << "C" << real << ", << imag « " )\n"; هه void Complex::print(const Complex &c) const { c.print(); مه

//Application.cpp #include <iostream> #include "Complex.h" using namespace std; int main() { Complex a(1.0, 2.0), 5(3.0, 4.0), C; //testing copy constructor Complex da); cout << "Copy constructor result: "; d.print(); //Testing overloaded + operator C = a + b; cout << "Complex number addition result: "; c.print(); //Testing overloaded - operator C = a - b; cout << "Complex number subtraction result: "; c.print(); //Testing overloaded * operator C = a* b; cout << "Complex number multiplication result: "; c.print();

//Testing overloaded / operator c = a / b; cout << "Complex number division result: "; c.print(); return 0; مه

Screenshot of output:-

Copy constructor result: (1, 2 > Complex number addition result: (4, 6 > Complex number subtraction result: < -2,-2 > Complex number multiplication result: (-5, 10 > Complex number division result: < 0.44, 0.08 >

Program code to copy:-

//Complex.h
#pragma once
#ifndef COMPLEX_H
#define COMPLEX_H
class Complex
{
private:
   double real;
    double imag;
public:
    // initialize the complex number to 0.0
    Complex() : real(0.0), imag(0.0) {}
    // initialize the complex number at declaration or new
    Complex(double r, double i) : real(r), imag(i) {}
    // this is actually the same as the default copy constructor provided by the compiler
    Complex(const Complex &c) : real(c.real), imag(c.imag) {}

    void setReal(double r) {real = r;}
    void setImag(double i) {imag = i;}
    void setComplex(const Complex &c) {real = c.real; imag = c.imag;}
    double getReal() const {return real;}
    double getImag() const {return imag;}
    Complex getComplex() const {return *this;}

   //Overloaded functions prototype
    Complex operator+(const Complex &) const;
    Complex operator-(const Complex &) const;
    Complex operator*(const Complex &) const;
    Complex operator/(const Complex &) const;

   //Print functions prototype
    void print() const;
    void print(const Complex &) const;
};

#endif

//Complex.cpp
#include <iostream>
using namespace std;
#include "Complex.h"

//addition(+) operator function overloading
Complex Complex::operator+(const Complex &c) const {
Complex result;
result.real = real + c.real;
result.imag = imag + c.imag;
return result;
}

//subtraction(-) operator function overloading
Complex Complex::operator-(const Complex &c) const {
Complex result;
result.real = real - c.real;
result.imag = imag - c.imag;
return result;
}

//multiplication(*) operator function overloading
Complex Complex::operator*(const Complex &c) const {
Complex result;
result.real = real * c.real - imag * c.imag;
result.imag = imag * c.real + real * c.imag;
return result;
}

//division(/) operator function overloading
Complex Complex::operator/(const Complex &c) const {
double t = c.real * c.real + c.imag * c.imag;
Complex result;
result.real = (real * c.real + imag * c.imag) / t;
result.imag = (imag * c.real - real * c.imag) / t;
return result;
}

//Functions to print the result
void Complex::print() const {
cout << "( " << real << ", " << imag << " )\n";
}

void Complex::print(const Complex &c) const {
c.print();
}

//Application.cpp
#include <iostream>
#include "Complex.h"
using namespace std;

int main() {
Complex a(1.0, 2.0), b(3.0, 4.0), c;

//testing copy constructor
Complex d(a);
cout << "Copy constructor result: ";
d.print();

//Testing overloaded + operator
c = a + b;
cout << "Complex number addition result: ";
c.print();

//Testing overloaded - operator
c = a - b;
cout << "Complex number subtraction result: ";
c.print();

//Testing overloaded * operator
c = a * b;
cout << "Complex number multiplication result: ";
c.print();

//Testing overloaded / operator
c = a / b;
cout << "Complex number division result: ";
c.print();

return 0;
}