Bruch.cs

using System;
using System.Collections.Generic;
using System.Text;

namespace _02_1_OpUeberladungBrueche
{
    class Bruch
    {
        int z, n;
        public Bruch(int Z, int N = 1)
        {
            z = Z;
            n = N;
        }

        #region Binäre Operatoren
        //public void Mult_V1(Bruch b)
        //{
        //    // Ergebnisse müssten in z,n gespeichert werden
        //    // Folge: Originalwerte werden überschrieben
        //}
        public Bruch Mult_V2(Bruch b)
        {
            int zneu = z * b.z;
            int nneu = n * b.n;
            Bruch neu = new Bruch(zneu, nneu);
            return neu;
        }
        public Bruch Mult_V3(Bruch b)
        {
            return new Bruch(z * b.z, n * b.n);
        }
        public Bruch Mult_V4(Bruch b)
            => new Bruch(this.z * b.z, this.n * b.n);
        public Bruch Mult_V4(int k)
            => new Bruch(z * k, n);
        // Voraussetzung bei allen zuvor aufgeführten nicht-statischen Methoden:
        // Es braucht links jeweils ein Bruch-Objekt!

        public static Bruch Mult_V5(Bruch b1, Bruch b2)
            => new Bruch(b1.z * b2.z, b1.n * b2.n);
        public static Bruch operator *(Bruch b1, Bruch b2)
            => new Bruch(b1.z * b2.z, b1.n * b2.n);
        //public static Bruch Mult_V5(Bruch b1, int k)
        //    => new Bruch(b1.z * k, b1.n );
        //public static Bruch Mult_V5(int k, Bruch b2)
        //    => new Bruch(k * b2.z, b2.n);
        public static Bruch operator <<(Bruch b, int x) => new Bruch(b.z * x, b.n * x);
        public static Bruch operator >>(Bruch b, int x) => new Bruch(b.z / x, b.n / x);
        #endregion

        #region Konvertierungsoperatoren
        public static implicit operator Bruch(int k) => new Bruch(k);
        // Macht aus einem int einen Bruch
        public static explicit operator Bruch(double d) => new Bruch((int) d);
        // Macht aus einem int einen Bruch

        public static explicit operator int(Bruch b) => b.z / b.n;
        // Macht aus einem Bruch einen int
        // Da etwas verloren gehen kann, explizite Konvertierung
        public static explicit operator double(Bruch b) => ((double) b.z / (double) b.n);
        #endregion

        #region Unäre Operatoren
        public static Bruch operator +(Bruch b) => b;
        public static Bruch operator -(Bruch b) => new Bruch(-b.z, b.n);

        // x = 5; cw(x++)--> cw(x); x=x+1  ,  cw(++x) --> x=x+1;cw(x)
        // b1++    3/2++  --> 5/2
        // Compiler generiert selbstätig die entsprechende Codeanordnung
        public static Bruch operator ++(Bruch b) => new Bruch(b.z + b.n, b.n);
        public static Bruch operator --(Bruch b) => new Bruch(b.z - b.n, b.n);
        #endregion

        #region Vergleichsoperatoren
        public static bool operator ==(Bruch b1, Bruch b2) => b1.z == b2.z && b1.n == b2.n;
        public static bool operator !=(Bruch b1, Bruch b2) => !(b1 == b2);

        public static bool operator true(Bruch b) => b.n != 1;
        // Nenner == 1 heißt ganze Zahl, kein echter Bruch
        public static bool operator false(Bruch b) => b.n == 1;
        public override bool Equals(object obj)
        {
            if (obj == null)
                return false;
            if (this.GetType() != obj.GetType()) 
                return false;
            
            return this == (Bruch)obj;
        }
        public override int GetHashCode()
        {
            return z.GetHashCode() ^ n.GetHashCode();
        }
        #endregion
        public override string ToString() => $"{z}/{n}";
    }
}