Exercice – Apprivoiser la surcharge d'opérateurs

Quelques exercices pour apprivoiser la surcharge d'opérateurs avec C#.

Activité – Une classe TiTableau

Nous allons coder une classe TiTableau, qui modélisera... un petit tableau unidimensionnel d'entiers de taille fixée à la construction.

Cette classe offrira une gamme de services ce base, soit :

Nous allons aussi implémenter quelques opérateurs pour cette classe, soit :

Un solutionnaire viendra, pour référence ultérieure.

Un solutionnaire possible serait :

class TaillesIncompatiblesException : Exception { }
public class TiTableau
{
   int[] Substrat { get; set; }
   public TiTableau(int n)
   {
      Substrat = new int[n];
   }
   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 { get => Substrat.Length;  }
   public bool Vide { get => Taille == 0; }
   public override bool Equals(object autre) =>
      autre is TiTableau tt && Equals(tt);
   public bool Equals(TiTableau autre)
   {
      if (Taille != autre.Taille) return false;
      for (int i = 0; i != Taille; ++i)
         if (this[i] != autre[i]) return false;
      return true;
   }
   public override int GetHashCode() =>
      base.GetHashCode(); // bof
   public static bool operator ==(TiTableau t0, TiTableau t1) =>
      (object) t0 != null && t0.Equals(t1);
   public static bool operator!=(TiTableau t0, TiTableau t1) => !(t0 == t1);
   public static bool operator <(TiTableau t0, TiTableau t1)
   {
      int i = 0;
      for (;  i != t0.Taille && i != t1.Taille; ++i)
         if (t0[i] != t1[i])
            return t0[i] < t1[i];
      if (t0.Taille == t1.Taille)
         return false; // t0 == t1
      return t0.Taille < t1.Taille;
   }
   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 (Vide)
         return "";
      string résultat = $"{this[0]}";
      for(int i = 1; i != Taille; ++i)
         résultat += String.Format($" {this[i]}");
      return résultat;
   }
}

Un programme de test possible serait :

class Program
{
   static void TestRelationnels(TiTableau tt0, TiTableau tt1)
   {
      if (tt0 == tt1)
         Console.WriteLine($"{tt0} == {tt1}");
      if (tt0 != tt1)
         Console.WriteLine($"{tt0} != {tt1}");
      if (tt0 < tt1)
         Console.WriteLine($"{tt0} < {tt1}");
      if (tt0 <= tt1)
         Console.WriteLine($"{tt0} <= {tt1}");
      if (tt0 > tt1)
         Console.WriteLine($"{tt0} > {tt1}");
      if (tt0 >= tt1)
         Console.WriteLine($"{tt0} >= {tt1}");
   }
   static void Main(string[] args)
   {
      TiTableau tt0 = new TiTableau(5);
      for (int i = 0; i != tt0.Taille; ++i)
         tt0[i] = i + 1;
      Console.WriteLine($"tt0 : {tt0}");
      TiTableau tt1 = new TiTableau(5);
      for (int i = 0; i != tt1.Taille; ++i)
         tt1[i] = i + 1;
      Console.WriteLine($"tt1 : {tt1}");
      TestRelationnels(tt0, tt1);
      Console.WriteLine($"{tt0} + {tt1} == {tt0 + tt1}");
      TestRelationnels(tt0, tt0 + tt1);
      Console.WriteLine($"-({tt0}) == {-tt0}");
      TestRelationnels(tt0, -tt0);
   }
}

... ce qui devrait afficher :

tt0 : 1 2 3 4 5
tt1 : 1 2 3 4 5
1 2 3 4 5 == 1 2 3 4 5
1 2 3 4 5 <= 1 2 3 4 5
1 2 3 4 5 >= 1 2 3 4 5
1 2 3 4 5 + 1 2 3 4 5 == 2 4 6 8 10
1 2 3 4 5 != 2 4 6 8 10
1 2 3 4 5 < 2 4 6 8 10
1 2 3 4 5 <= 2 4 6 8 10
-(1 2 3 4 5) == -1 -2 -3 -4 -5
1 2 3 4 5 != -1 -2 -3 -4 -5
1 2 3 4 5 > -1 -2 -3 -4 -5
1 2 3 4 5 >= -1 -2 -3 -4 -5

Exercice – Une classe Point

À titre d'exercice, vous allez coder une classe Point modélisant un point 2D. Cette classe offrira les services suivants :

Écrivez un programme de test pour valider votre oeuvre.


Valid XHTML 1.0 Transitional

CSS Valide !