Изменить код. ООП

RMaxPlus.h
#ifndef RMAXPLUS_HPP
#define RMAXPLUS_HPP
 
 
class RMaxPlus
{
public:
    RMaxPlus();
    RMaxPlus(double value);
    RMaxPlus(RMaxPlus& other);
    RMaxPlus operator+(RMaxPlus &a);
    RMaxPlus operator*(RMaxPlus &a);
 
    static const RMaxPlus zero;
    static const RMaxPlus unit;
 
    double value;
};

RMaxPlus.cpp
#include "RMaxPlus.h"
 
 
const RMaxPlus RMaxPlus::zero = RMaxPlus(100500);
const RMaxPlus RMaxPlus::unit = RMaxPlus(0);
 
 
RMaxPlus::RMaxPlus(): value(0)
{
}
 
 
RMaxPlus::RMaxPlus(double value): value(value)
{
}
 
 
RMaxPlus::RMaxPlus(RMaxPlus& other): value(other.value)
{
}
 
 
RMaxPlus RMaxPlus::operator+(RMaxPlus& a)
{
    RMaxPlus b,c;
    b.value=value;
    c.value=a.value;
    if(b.value>c.value)
        return b;
    else
        return c;
}
 
 
RMaxPlus RMaxPlus::operator*(RMaxPlus& a)
{
    RMaxPlus b;
    b.value=value+a.value;
    return b;
}

RMaxMin.h
#ifndef RMAXMIN_HPP
#define RMAXMIN_HPP
 
 
class RMaxMin
{
public:
    RMaxMin();
    RMaxMin(double value);
    RMaxMin(RMaxMin& other);
    RMaxMin operator+(RMaxMin& a);
    RMaxMin operator*(RMaxMin& a);
 
    static const RMaxMin zero;
    static const RMaxMin unit;
 
    double value;
};
 
 
#endif RMAXMIN_HPP

RMaxMin.cpp
#include "RMaxMin.h"
 
 
const RMaxMin RMaxMin::zero = RMaxMin(-1000);
const RMaxMin RMaxMin::unit = RMaxMin(1000);
 
 
RMaxMin::RMaxMin(): value(0)
{
}
 
 
RMaxMin::RMaxMin(double value): value(value)
{
}
 
 
RMaxMin::RMaxMin(RMaxMin& other): value(other.value)
{
}
 
 
RMaxMin RMaxMin::operator+(RMaxMin& a)
{
    RMaxMin b,c;
    b.value=value;
    c.value=a.value;
    if(b.value>c.value)
        return b;
    else
        return c;
}
 
 
RMaxMin RMaxMin::operator*(RMaxMin& a)
{
    RMaxMin b,c;
    b.value=value;
    c.value=a.value;
    if(b.value<c.value)
        return b;
    else
        return c;
}

RMinPlus.h
#ifndef RMINPLUS_HPP
#define RMINPLUS_HPP
 
 
class RMinPlus
{
public:
    RMinPlus();
    RMinPlus(double value);
    RMinPlus(RMinPlus& other);
    RMinPlus operator+(RMinPlus& a);
    RMinPlus operator*(RMinPlus& a);
 
    static const RMinPlus zero;
    static const RMinPlus unit;
 
    double value;
};
 
 
#endif RMINPLUS_HPP

RMinPlus.cpp
#include "RMinPlus.h"
 
 
const RMinPlus RMinPlus::zero = RMinPlus(-1000);
const RMinPlus RMinPlus::unit = RMinPlus(0);
 
 
RMinPlus::RMinPlus(): value(0)
{
}
 
 
RMinPlus::RMinPlus(double value): value(value)
{
}
 
 
RMinPlus::RMinPlus(RMinPlus& other): value(other.value)
{
}
 
 
RMinPlus RMinPlus::operator+(RMinPlus& a)
{
    RMinPlus b,c;
    b.value = value;
    c.value = a.value;
    if(b.value < c.value)
        return b;
    else
        return c;
}
 
 
RMinPlus RMinPlus::operator*(RMinPlus& a)
{
    RMinPlus b;
    b.value=value+a.value;
    return b;
}

main.cpp
#include<iostream>
using namespace std;
#include"RMinPlus.h"
#include"RMaxPlus.h"
#include"RMaxMin.h"
void main()
{
    RMinPlus a,a1;
    RMaxPlus b, e;
    RMaxMin c, y;
    a.value=1;
    a1.value=2;
    b.value=3;
    e.value=4;
    c.value=5;
    y.value=6;
    cout<<((a+a1)*a1).value<<endl;
    cout<<((a1+a)*a).value<<endl;
    cout<<((b+e)*b).value<<endl;
    cout<<((e+e)*b).value<<endl;
    cout<<((c+y)*y).value<<endl;
    cout<<((c+c)*y).value<<endl;
    system("pause");
}

#include<iostream>
using namespace std;
 
void main()
{
   
    int a = 1;
    int a1 = 2;
    int b= 3;
    int e = 4;
    int c = 5;
    int y = 6;
    cout<<((a < a1 ? a : a1) + a1) <<endl;
    cout<<(((a1 < a) ? a1 : a) + a) <<endl;
    cout<<((b > e ? b : e) + b) <<endl;
    cout<<(e + b) <<endl;
    cout<<((c > y ? c : y) + ((c > y ? c : y) <  y ? (c > y ? c : y) : y)) << endl;
    cout<<(c < y ? c : y) <<endl;
    system("pause");
}