Shitty Comp Sci HW

// M5,6,7,8,9,11

// === M5 === //
// #1

int Demo11::getVal1() const {
    return val1;
}

int Demo11::getVal2() const {
    return val2;
}

Demo11 Demo11::subDemo11A(const Demo11 &obj1, const Demo11 &obj2) {
    Demo11 newObj;
    newObj.val1 = obj1.val1 - obj2.val1,
    newObj.val2 = obj1.val2 - obj2.val2;
    return newObj;
}

void Demo11::decrementDemo11A(Demo11 &obj) {
    obj.val1 -= 1;
    obj.val2 -= 1;
}

// #2

Demo11 subDemo11B(const Demo11 &obj1, const Demo11 &obj2) {
    Demo11 newObj;
    newObj(obj1.getVal1() - obj2.getVal1(), obj1.getVal2() - obj2.getVal2());
    return newObj;
}

// #3

void decrementDemo11B(Demo11 &obj) {
    obj(obj.getVal1() - 1, obj.getVal2() - 1);
}

// #4

// A
obj4 = obj4.subDemo11A(obj1, obj2);

// B
obj4 = subDemo11B(obj1, obj2);

// === M6 === //

// #1
class Demo12 {
    public:
        Demo12(int n1 = 0, int n2 = 0); // constructor
        int getFirst( ); // returns the value of the first member variable
        int getSecond( ); // returns the value of the second member variable
        friend Demo12 operator +(const Demo12 &ob1, const Demo12 &obj2);
        friend bool operator ==(const Demo12 &ob1, const Demo12 &obj2);
        friend Demo12 operator ++(Demo12 &obj);
        friend Demo12 operator -(const Demo12 &obj1, const Demo12 &obj2);
        friend bool operator >(const Demo12 &obj1, const Demo12 &obj2);
        friend Demo12 operator --(Demo12 &obj);
    private:
        int val1;
        int val2;
};

// #2

robj = tobj - sobj;

--robj;

int num1, num2;
cin >> num1 >> num2;
uobj(num1, num2);
if (uobj > robj)
    cout << "I am happy.";
else
    cout << "I am sad.";

// === M7 === //

class Triplet1 {
    public:
        Triplet1(int val1 = 1, int val2 = 1, int val3 = 1);
        int getFirst();
        int getSecond();
        int getThird();
        friend Triplet1 operator ++(Triplet1 &obj);
    private:
        int first;
        int second;
        int third;
}

// === M8 === //

class Triplet2 {
    public:
        Triplet1(int val1 = 1, int val2 = 1, int val3 = 1);
        int getFirst();
        int getSecond();
        int getThird();
        friend Triplet1 operator -(Triplet2 &obj1, Triplet2 &obj2);
        friend Triplet1 operator ++(Triplet2 &obj);
        friend bool operator <=(Triplet2 &obj1, Triplet2 &obj2);
    private:
        int first;
        int second;
        int third;
}

// === M9 === //

// Cry, this part is SOOOOO hard and SOOOO long (but not in the good way ;3) that youll take way longer than it took me to do the rest to do this.

// === M11 === //

class DynamicP() {
    public:
        DynamicP(char newSymb = 'A', int ival = 50, double dval = 12.50);
        ~DynamicP();
        friend DynamicP operator =(const DynamicP &obj1, const DynamicP &obj2);
        void read();
        void write();
        void set_symb(char newSymb);
        void set_iptr(int iVal);
        void set_dptr(double dVal);
        char get_symb();
        int get_iptr();
        double get_dptr();
    private:
        char symb;
        int *iptr;
        double *dptr;
}

DynamicP::DynamicP(char newSymb, int ival, double dval) {
    symb = newSymb;
    iptr = new int;
    *iptr = ival;
    dptr = new double;
    *dptr = dval;
}

DynamicP::~DynamicP() {
    delete iptr;
    delete dptr;
}

void DynamicP::read() {
    cin >> symb >> *iptr >> *dptr;
}

void DynamicP::write() {
    cout << symb << *iptr << *dptr;
}

void DynamicP::set_symb(char newSymb) {
    symb = newSymb;
}

void DynamicP::set_iptr(int iVal) {
    *iptr = iVal;
}

void DynamicP::set_dptr(double dVal) {
    *dptr = dVal;
}

char DynamicP::get_symb() {
    return symb;
}

int DynamicP::get_iptr() {
    return *iptr;
}

double DynamicP::get_dptr() {
    return *dptr;
}