Exercice – Apprivoiser la surcharge d'opérateurs

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

Activité – 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 de 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

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 – 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ères 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éthodepour évaluer la distance entre deux points. Rappel : la formule pour évaluer la distance entre deux points $p_0$ et $p_1$ est $\sqrt{(p_0.X-p_1.X)^2 + (p_0.Y-p_1.Y)^2}$

Écrivez un programme de test pour valider votre oeuvre.

Exercice – Classe Naturel

À titre d'exercice, vous allez coder une classe Naturel modélisant entier naturel, donc dont la valeur est supérieure ou égale à zéro. Cette classe offrira les services suivants :

Les opérateurs arithmétiques usuels (+ et - unaires – est-ce une bonne idée selon vous? – de même que +, -, *, / et % binaires)
Les opérateurs relationnels (<, <=, >, >=, == et !=)
Les opérateurs ++ et --
Un constructeur par défaut, modélisant un Naturel de valeur 0
Un constructeur paramétrique, modélisant un Naturel de valeur choisie par le code client

Écrivez un programme de test pour valider votre oeuvre. Toute tentative de placer un Naturel dans un état incorrect devrait lever ErreurDomaineException.