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 :

• Une propriété privée Substrat qui donnera accès au tableau de int encapsulé dans un TiTableau
• Un constructeur paramétrique public acceptant en paramètre la taille du TiTableau (exprimée en nombre d'éléments), et qui instanciera le tableau de int sous-jacent (le Substrat)
• Une méthode publique Contient() acceptant en paramètre une valeur entière, et retournant true seulement si cette valeur est dans le TiTableau
• Une propriété publique Taille permettant de consulter le nombre d'éléments du tableau, mais ne permettant pas de le changer
• Une propriété publique Vide qui sera vraie seulement si le nombre d'éléments du tableau est zéro
• Une méthode ToString(), spécialisation de celle de la classe object, qui retournera une chaîne comprenant les entiers dans le TiTableau et séparés les uns des autres par un espace (conséquemment, si le TiTableau nommé tt contient les entiers 1, 2 et 3 dans l'ordre, alors tt.ToString() donnera la chaîne "1 2 3" (notez qu'il n'y a pas d'espace au début et à la fin de cette chaîne)

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

• Les opérateurs relationnels (==, !=, <, <=, >, >=). Notez que Les opérateurs relationnels d'ordonnancement implémenteront un ordonnancement lexicographique (grosso modo : l'ordre du dictionnaire, mais avec des séquences d'entiers au lieu de séquences de caractères).
• Un opérateur + binaire (deux opérandes) tel que (1 2 3)+(1 2 4) vaudra (2 4 7)
• Un opérateur - unaire (une opérande) tel que -(1 2 3) vaudra (-1 -2 -3)
• Un indexeur (version C# de l'opérateur [] sous forme de propriété) pour que le TiTableau se comporte un peu comme un tableau

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() // serait plus rapide avec un StringBuilder
   {
      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 :

TiTableau tt0 = new (5);
for (int i = 0; i != tt0.Taille; ++i)
   tt0[i] = i + 1;
Console.WriteLine($"tt0 : {tt0}");
TiTableau tt1 = new (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);

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}");
}

... 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 :

• Des propriétés publiques entière X et Y
• Un opérateur == et un opérateur != pour comparer deux instances de Point
• Un opérateur + binaire tel que (X0,Y0) + (X1,Y1) donnera (X0+X1,Y0+Y1)
• Un opérateur - unaire tel que -(X,Y) donnera (-X,-Y)
• Un constructeur par défaut, modélisant un Point à l'origine
• Un constructeur paramétrique, modélisant un Point à une position (X,Y) choisie par le code client
• Une méthode Distance() pour évaluer la distance entre deux points

Écrivez un programme de test pour valider votre oeuvre.

Exercice – Une classe Matrice2D

À titre d'exercice, vous allez coder une classe Matrice2D modélisant une matrice 2D de double. Cette classe offrira les services suivants :

• Un constructeur paramétrique prenant en paramètre le nombre de lignes et le nombre de colonnes de la matrice
• Des propriétés de second ordre NbLignes et NbColonnes
• Un opérateur * binaire implémentant la multiplication matricielle (rappel : nous l'avons implémenté en S1)
• Un opérateur == et un opérateur != (vous pouvez utiliser une fonction AssezProches pour comparer les valeurs individuellement)
• Une méthode Inverse qui retourne l'inverse de la matrice
• Un indexeur à deux paramètres pour accéder à une case de la matrice
• Une méthode ToString

Écrivez un programme de test pour valider votre oeuvre.