#include <iostream>
#include <fstream>
#include <iomanip>
#include <math.h>

using namespace std;

class TreeNode {
    public:
	int data;
	TreeNode * left;
	TreeNode * right;
};

class BinarySearchTree {
    public:
	BinarySearchTree() { root=NULL; }
	void add(int value);
	void inorder();
    private:
	TreeNode * root;
	void inorderHelper(TreeNode * node);
};
void BinarySearchTree::inorder() {
    cout << "Start Print BST" << endl;
    inorderHelper(root);
    cout << "End Print BST" << endl;
}
void BinarySearchTree::inorderHelper(TreeNode * node) {
    if (root==NULL) {
	return;
    }
    inorderHelper(node->left);
    cout << node->data << endl;
    inorderHelper(node->right);
}
void BinarySearchTree::add(int value) {
    // start of solution to question 1


    // end of solution to question 1
}

class Exception {
    public:
	Exception(char*s) { msg=s; }
	virtual void print() { cout << msg << endl; }
    protected:
	char *msg;
};

class UnimplementedMethodException: Exception {
    public:
	UnimplementedMethodException(char*s):Exception(s) {}
	virtual void print() { cout << "Not Implemented @ " << msg << endl; }
};
class DivisionByZeroException: Exception {
    public:
	DivisionByZeroException(char*s):Exception(s) {}
	virtual void print() { cout << "Division By 0 @ " << msg << endl; }
};

class Computable {
    public:
	virtual Computable operator+(const Computable& c2) const;
	virtual Computable operator-(const Computable& c2) const;
	virtual Computable operator*(const Computable& c2) const;
	virtual Computable operator/(const Computable& c2) const;
	virtual void print() const;
};
Computable Computable::operator+(const Computable& c2) const {
    UnimplementedMethodException e("Computable::operator+()");
    throw e;
}
Computable Computable:: operator-(const Computable& c2) const {
    UnimplementedMethodException e("Computable::operator+()");
    throw e;
}
Computable Computable::  operator*(const Computable& c2) const {
    UnimplementedMethodException e("Computable::operator+()");
    throw e;
}
Computable Computable:: operator /(const Computable& c2) const {
    UnimplementedMethodException e("Computable::operator+()");
    throw e;
}
void Computable::print() const {
    UnimplementedMethodException e("Computable::print()");
    throw e;
}
class Real : public Computable {
    private:
	double real;
    public:
	Real(double value) { real=value; }
	virtual Real operator+(const Real& c2) const;
	virtual Real operator -(const Real& c2) const;
	virtual Real operator*(const Real& c2) const;
	virtual Real operator/(const Real& c2) const;
	virtual void print() const;
};
Real Real::operator+(const Real& c2) const {
    Real result(real+c2.real);
    return result;
}
Real Real::operator-(const Real& c2) const {
    Real result(real-c2.real);
    return result;
}
Real Real::operator*(const Real& c2) const {
    Real result(real*c2.real);
    return result;
}
Real Real::operator/(const Real& c2) const {
    if (c2.real==0.0) {
	DivisionByZeroException e("Real::operator/()");
	throw e;
    }
    Real result(real/c2.real);
    return result;
}
void Real::print() const {
    cout << real << endl;
}

class Complex : public Computable {
    private:
	double real;
	double imaginary;
    public:
	Complex(double r, double i) { real=r; imaginary=i; }
	virtual Complex operator+(const Complex& c2) const;
	virtual Complex operator-(const Complex& c2) const;
	virtual Complex operator*(const Complex& c2) const;
	virtual Complex operator/(const Complex& c2) const;
	virtual void operatorcomplex() const;
	virtual void print() const;
};
Complex Complex::operator+(const Complex& c2) const {
    Complex result(real+c2.real,imaginary+c2.imaginary);
    return result;
}
Complex Complex::operator-(const Complex& c2) const {
    Complex result(real-c2.real,imaginary-c2.imaginary);
    return result;
}
Complex Complex::operator*(const Complex& c2) const {
    Complex result(real*c2.real - imaginary*c2.imaginary,
	    real*c2.imaginary + imaginary*c2.real);
    return result;
}
Complex Complex::operator/(const Complex& c2) const {
	UnimplementedMethodException e("Complex::inverse()");
	throw e;
}
void Complex::operatorcomplex() const {
    // this method is defined to provide an extra test case for your regular expression
}
void Complex::print() const {
    cout << real << " + " << imaginary << "i" << endl;
}

void q2() {
    cout << "start q2" << endl;
    Complex c1(1.0,2.0);
    Complex c2(2.0,3.0);
    Complex c3=c1+c2;
    Complex c4=c1-c2;
    Complex c5=c1*c2;
    Real i1(3.0);
    Real i2(4.0);
    Real i3=i1+i2;
    Real i4=i1-i2;
    Real i5=i1*i2;
    c3.print();
    c4.print();
    c5.print();
    i3.print();
    i4.print();
    i5.print();
    cout << "end q2" << endl;
}

    /* start of solution to question 2

Output:


Computable:
objects=  copy constructors=  non-copy constructors=  destructors= 

Real:
objects=  copy constructors=  non-copy constructors=  destructors= 

Complex:
objects=  copy constructors=  non-copy constructors=  destructors= 

     end of solution to question 2 */

void q3() {
    cout << "start q3" << endl;
    Complex x(1.0,2.0);
    Complex y(2.0,3.0);
    Complex z(0.0,0.0);
    Complex i1(0.0,0.0);
    Complex i2(0.0,0.0);
    Complex i3(0.0,0.0);
    Complex i4(0.0,0.0);
    try {
    i1=x+y;
    i2=x*y;
    i3=x/z;
    i4=z-y;
    } 
    catch (Exception& e) {
	cout << "haha"<<endl;
	e.print();
    }
    catch (DivisionByZeroException& e) {
	e.print();
    }
    catch (UnimplementedMethodException& e) {
	cout << "hoho"<<endl;
	e.print();
    }
    i1.print();
    i2.print();
    i3.print();
    i4.print();
    cout << "end q3" << endl;
}
    /* start of solution to question 3

Output:


Exception: 
objects=  copy constructors=  non-copy constructors=  destructors= 

DivisionByZeroException:
objects=  copy constructors=  non-copy constructors=  destructors= 

UnimplementedMethodException:
objects=  copy constructors=  non-copy constructors=  destructors= 

Computable:
objects=  copy constructors=  non-copy constructors=  destructors= 

Complex:
objects=  copy constructors=  non-copy constructors=  destructors= 

     end of solution to question 3 */
    

static char*err=NULL;

    // start of solution to question 5
int add5(const int& c1, const int& c2) {
    return 0;
}
int sub5(const int& c1, const int& c2) {
    return 0;
}
int mul5(const int& c1, const int& c2) {
    return 0;
}
int div5(const int& c1, const int& c2) {
    return 0;
}

/* The output that should be the result of calling q5():



   */
// end of solution to question 5
void q5() {
    cout << "start q5" << endl;
    int x=1;
    int y=2;
    int z=0;
    int i1=0;
    int i2=0;
    int i3=0;
    int i4=0;
    i1=add5(x,y);
    i2=mul5(x,y);
    i3=div5(x,z);
    i4=sub5(z,y);
    if (err!=NULL) {
	cout << "An error occurred @ " << err << endl;
	err=NULL;
    }
    cout << i1 << " " << i2 << " " << i3 << " " << i4 << endl;
    cout << "end q5" << endl;
}

int main() {
    BinarySearchTree bst;
    bst.add(2);
    bst.add(3);
    bst.add(4);
    bst.add(2);
    bst.add(1);
    bst.inorder();

    q2();

    q3();

    Complex c1(1.0,2.0);
    Real r1(3.0);
    Complex c2=r1*c1;
    c2.print(); // should print out 3 + 6i

    q5();

}

/* solution to question 6
Replace RE in the line below with the actual regular expression 
egrep 'RE' a4.cc
     */

/* solution to question 7
 
     */