Solutionnaire des exercices pour apprivoiser la surcharge d'opérateurs

class TaillesIncompatiblesException : Exception;
public class TiTableau : IEquatable<TiTableau>, IComparable<TiTableau>
{
   int[] Substrat { get; init; }
   public TiTableau(int n) : this(n, 0)
   {
   }
   public TiTableau(int n, val)
   {
      Substrat = new int[n];
      for(int i = 0; i != Taille; ++i)
         Substrat[i] = val;
   }
   public int this[int n]
   {
      get => Substrat[n];
      set
      {
         Substrat[n] = value;
      }
   }
   public bool Contient(int val)
   {
      foreach (int n in Substrat)
         if (n == val) return true;
      return false;
   }
   public int Taille => Substrat.Length;
   public bool EstVide => Taille == 0;
   public override bool Equals(object autre) =>
      autre is TiTableau tt && Equals(tt);
   public bool Equals(TiTableau ? autre)
   {
      if (autre is null || Taille != autre.Taille) return false;
      for (int i = 0; i != Taille; ++i)
         if (this[i] != autre[i]) return false;
      return true;
   }
   public int CompareTo(TiTableau ? autre)
   {
      if(autre is null) return 1;
      int lg = Math.Min(Taille, autre.Taille);
      for (int i = 0; i != lg; ++i)
         if (this[i] != autre[i])
            return this[i].CompareTo(autre[i]);
      return Taille.CompareTo(autre.Taille);

   }
   public override int GetHashCode() => Substrat.GetHashCode();
   public static bool operator ==(TiTableau t0, TiTableau t1) =>
      t0.Equals(t1);
   public static bool operator!=(TiTableau t0, TiTableau t1) => !(t0 == t1);
   public static bool operator <(TiTableau t0, TiTableau t1) => t0.CompareTo(t1) < 0;
   public static bool operator >(TiTableau t0, TiTableau t1) => t1 < t0;
   public static bool operator <=(TiTableau t0, TiTableau t1) => !(t1 < t0);
   public static bool operator >=(TiTableau t0, TiTableau t1) => !(t0 < t1);
   public static TiTableau operator+(TiTableau t0, TiTableau t1)
   {
      if (t0.Taille != t1.Taille) throw new TaillesIncompatiblesException();
      TiTableau résultat = new TiTableau(t0.Taille);
      for (int i = 0; i != résultat.Taille; ++i)
         résultat[i] = t0[i] + t1[i];
      return résultat;
   }
   public static TiTableau operator -(TiTableau tt)
   {
      TiTableau résultat = new TiTableau(tt.Taille);
      for (int i = 0; i != résultat.Taille; ++i)
         résultat[i] = -tt[i];
      return résultat;
   }
   public override string ToString()
   {
      if (EstVide) // cas dégénéré
         return "";
      StringBuilder sb = new();
      sb.Append($"{this[0]}");
      for(int i = 1; i != Taille; ++i)
         sb.Append($" {this[i]}");
      return sb.ToString();
   }
}

usinng static System.Math;
public class Point : IEquatable<Point>
{
   public int X{ get; init; }
   public int Y{ get; init; }
   public Point() : this(0,0)
   {
   }
   public Point(int x, int y)
   {
      X = x
      Y = y;
   }
   public static Point operator+(Point p0, Point p1) => new(p0.X + p1.X, p0.Y + p1.Y);
   public static Point operator-(Point p) => new(p.X, -p.Y);
   public static double Distance(Point p0, Point p1) =>
      Sqrt(Pow(p0.X - p1.X, 2) + Pow(p0.Y - p1.Y, 2));
   // si c'était une méthode d'instance, on écrirait :
   // public double Distance(Point autre) =>
   //   Sqrt(Pow(X - autre.X, 2) + Pow(Y - autre.Y, 2));
   public override bool Equals(object ? autre) => autre is Point pt && Equals(pt);
   public override int GetHashCode() => HashCode.Combine(X, Y);
   public bool Equals(Point autre) => X == autre.X && Y == autre.Y;
   public static bool operator==(Point p0, Point p1) => p0.Equals(p1);
   public static bool operator!=(Point p0, Point p1) => !(p0 == p1);
}

class ErreurDomaineException : Exception {}
class Naturel : IEquatable<Naturel>, IComparable<Naturel>
{
   int valeur;
   int Valeur
   {
      get => valeur;
      init
      {
         valeur = value >= 0 ? value : throw new ErreurDomaineException();
      }
   }
   public Naturel()
   {
      Valeur = 0;
   }
   public Naturel(int valeur)
   {
      Valeur = valeur;
   }
   // opérateurs arithmétiques unaires
   public static Naturel operator+(Naturel n) => new (n.Valeur);
   public static Naturel operator-(Naturel n) => new (-n.Valeur); // lèvera une exception (aurait-on dû l'implémenter?)
   // opérateurs arithmétiques binaires
   public static Naturel operator+(Naturel n0, Naturel n1) => new (n0.Valeur + n1.Valeur);
   public static Naturel operator-(Naturel n0, Naturel n1) => new (n0.Valeur - n1.Valeur); // lèvera peut-être une exception
   public static Naturel operator*(Naturel n0, Naturel n1) => new (n0.Valeur * n1.Valeur);
   public static Naturel operator/(Naturel n0, Naturel n1) => new (n0.Valeur / n1.Valeur); // peut lever DivideByZeroException
   public static Naturel operator%(Naturel n0, Naturel n1) => new (n0.Valeur % n1.Valeur); // peut lever DivideByZeroException
   // opérateurs relationnels
   public static bool operator<(Naturel n0, Naturel n1) => n0.Valeur < n1.Valeur;
   public static bool operator<=(Naturel n0, Naturel n1) => !(n1 < n0);
   public static bool operator>(Naturel n0, Naturel n1) => n1 < n0;
   public static bool operator>=(Naturel n0, Naturel n1) => !(n0 < n1);
   public bool Equals(Naturel n) => Valeur == n.Valeur;
   public int CompareTo(Naturel n) => Valeur.CompareTo(n.Valeur);
   public static bool operator==(Naturel n0, Naturel n1) => (object) n0 != null && n0.Equals(n1);
   public static bool operator!=(Naturel n0, Naturel n1) => !(n0 == n1);
   public override bool Equals(object obj) => obj is Naturel n && Equals(n);
   public override int GetHashCode() => Valeur.GetHashCode();
}