Наследование и перегрузка операторов.

class myfloat
{
protected:
    int c;
    int z;
    void reduce();
public:
    myfloat(float num=0);
    myfloat(int i,int j);
    void print();
    friend myfloat operator+(myfloat,myfloat);
    friend myfloat operator-(myfloat,myfloat);
    friend myfloat operator*(myfloat,myfloat);
    friend myfloat operator/(myfloat,myfloat);
};

class saturation:public myfloat
{
    bool flag;
    void CheckLimit();
public:
    saturation(float=0);
    void show();
    friend saturation operator+(saturation,saturation);
    friend saturation operator-(saturation,saturation);
    friend saturation operator*(saturation,saturation);
    friend saturation operator/(saturation,saturation);
};

saturation operator+(saturation A,saturation B)
{
    //ВЫЗОВ ОПЕРАТОРА + ИЗ КЛАССА myfloat
    //ВЫЗОВ Функции CheckLimit() из класса saturation для A, судя по всему-   A.CheckLimit();
    return /* Что-то */;
}

myfloat(A)=operator +((myfloat)A,(myfloat)B);

saturation operator+(saturation& A, saturation& B)
{
   saturation C;
   static_cast<myfloat>(C)=static_cast<myfloat>(A)+static_cast<myfloat>(B);
   return C;
}

#include <iostream>
 
class base
{
 
public:
    
    base(int x)
        : _x(x) {}
        
    base(const base& rhs)
        : _x(rhs._x) {}
        
    virtual base operator + (const base& rhs)
    {
        base b(_x + rhs._x);
        return b;
    }
    
    virtual void show()
    {
        std::cout << _x << std::endl;
    }
    
protected:
    
    int _x;
};
 
class derived: public base
{
    
public:
    
    derived(int x, bool f)
        : base(x), _flag(f) {}
        
    derived(const derived& rhs)
        : base(rhs._x), _flag(rhs._flag) {}
        
    derived(const base& rhs)
        : base(rhs), _flag(DEFAULT_FLAG) {}
        
    void setFlag(bool f)
    {
        _flag = f;
    }
        
    operator base()
    {
        return base(_x);
    }
    
    derived operator + (const derived& rhs)
    {
        derived d = static_cast<base>(*this) + static_cast<base>(rhs);
        d.setFlag(_flag | rhs._flag);
        return d;
    }
    
    void show()
    {
        if(_flag)
            base::show();
    }
    
private:
 
    bool _flag;
    const static bool DEFAULT_FLAG = false;
};
 
int main()
{
    derived d1(3, false), d2(2, true), d3 = d1 + d2;
    d3.show();
    return 0;
}

friend std::ostream operator << (std::ostream& os, const base& rhs);

ostream& operator << (const base& rhs);

myfloat C = A + B;

class Int
{
public:
    Int(){}
    ~Int(){}
    Int operator +(const Int&Ob);
    friend Int operator +(const Int& Ob, const int elem);
    friend Int operator +(const int elem, const Int& Ob);
protected:
    int i;
};

const Int& Ob

class MyInt{
public:
    MyInt(int value=0): v(value) {}
    MyInt& operator += (const MyInt& op2) 
    {
        v += op2.v;                                 // Добавляем второй операнд
        return *this;                                // Возвращаем ссылку на первый операнд
    }
    MyInt operator + (const MyInt& op2) const
    {
        MyInt returnValue(*this);  // Создаём новый объект MyInt, копируя данные из первого операнда
        returnValue += op2;         // Прибавляем второй операнд
        return returnValue;          // Возвращаем по значению
    }
private:
    int v;
};

saturation::saturation(const myfloat &src, bool flag_=false): myfloat(src), flag(flag_) {}

saturation& saturation::operator += (const saturation& op2)
{
    static_cast<myfloat&>(*this) += op2;
    flag = true;
    return *this;
}
 
saturation saturation::operator + (const saturation& op2) const
{
    return saturation(static_cast<myfloat&>(*this)+op2, true);
}

saturation::saturation(myfloat num):myfloat(num)
{
    flag=0;
    CheckLimit();
}

saturation operator+(saturation A,saturation B)
{
    return saturation(static_cast<myfloat>(A)+static_cast<myfloat>(B));
}

saturation operator + (const saturation &op1, const saturation &op2)
{
    return static_cast<myfloat&>(op1) + op2;
}

saturation operator+(const saturation &A,const saturation &B)
{
    return static_cast<myfloat>(A)+static_cast<myfloat>(B);
}