420-SF2-RE – Structures de données et programmation orientée objet

Quelques raccourcis :

Ceci est un petit site de support pour le cours 420-SF2-RE – Structures de données et programmation orientée objet.

Vous trouverez aussi des liens sur divers langages (dont C#, notre outil de prédilection dans ce cours) un peu partout dans http://h-deb.clg.qc.ca/

Les diverses sections de cette page (en fonction desquelles vous trouverez quelques liens dans l'encadré à droite) vous mèneront elles-aussi sur des pistes qui vous permettront d'explorer un peu plus par vous-mêmes, de valider vos acquis et d'enrichir votre apprentissage

Cliquez sur cette cible pour le plan de cours, sous forme électronique

Pratiques de correction

Je corrige les programmes en appliquant des codes de correction. Vous trouverez ici la liste des codes les plus fréquents.

Ma stratégie de correction en tant que telle (pour le code, à tout le moins) est résumée ici.

Cliquez sur cette cible pour un résumé des principales règles de programmatique en vigueur dans ce cours.

Cliquez sur cette cible pour les normes appliquées dans ce cours, en ce qui a trait au pseudocode

Détail des séances en classe

Date Séance Détails

24 et 25 janvier

S00

Au menu :

  • Présentation du cours et du plan de cours
  • Petit exercice de remise en forme

Notez qu'en ce premier cours, nous investissons nos efforts sur deux aspects, soit :

  • Reprendre la forme intellectuelle après le congé des Fêtes, et
  • Mettre en place le vocabulaire et les idées qui guideront nos réflexions en ce début de session

Ça fait un gros cours pour démarrer la session, mais nous réinvestirons le tout cours après cours, alors ça va entrer doucement dans notre tête, et s'intégrer à notre praxis émergente 🙂.

  • Mise en place du vocabulaire de base de la POO, mais sous forme d'un survol seulement, et avec accent sur l'encapsulation (sans la nommer, mais vous ne perdez rien pour attendre!). Ainsi, nous avons identifié et situé les termes et idées suivant(e)s :
    • une maxime importante : « un objet est responsable de son intégrité, du début à la fin de sa vie »
    • quelques mots clés qui aident à encadrer la capacité d'un objet à assurer son encapsulation, soit les qualifications d'accès private et public
      • nous n'avons pas vraiment parlé de protected, qui a une utilité réelle mais plus limitée que des deux autres, et dont nous ne pouvons pas traiter pour le moment
      • nous avons toutefois insisté sur le fait que private, la qualification par défaut des membres dans une classe, est ce que nous souhaitons utiliser le plus possible, et nous avons donné quelques raisons pour soutenir cette prise de position
      • nous avons démontré que public, du moins pour les états d'un objet, devrait être évité dans la plupart des cas, cette qualification empêchant de facto l'objet d'assurer son encapsulation
  • Nous avons mis de l'avant quelques mots de vocabulaire plus techniques, soit :
    • les méthodes, qui sont les services (les fonctions, les comportements) d'un objet
    • les attributs, qui sont les états (variables, constantes) d'un objet
    • les constructeurs, qui sont les méthodes un peu spéciales mais Ô combien importantes qui permettent de déterminer l'état initial d'un objet – sans eux, pas d'état initial connu pour un objet, donc pas d'encapsulation pour lui
  • Nous avons discuté du glissement sémantique entre F(obj), où on applique une opération sur une entité , ce qui rejoint l'approche procédurale que nous avons mis en application dans le cours 420-SF1-RE, et obj.F(), qui sollicite la méthode de l'objet et rend ce dernier actif
  • Nous avons discuté brièvement des accesseurs (méthodes de consultation) et des mutateurs (méthodes de modification), qui sont des familles de services typiques pour les objets
    • La partie get d'une propriété est un exemple d'accesseur
    • La partie set d'une propriété est un exemple de mutateur
    • La partie init d'une propriété est aussi un exemple de mutateur, mais qui ne fonctionne que durant la construction d'un objet. Évidemment, une propriété ne peut pas avoir à la fois un set et un init (c'est l'un ou l'autre)
    • Il est évidemment possible d'écrire des méthodes qui ont on comportement d'accesseur ou un comportement de mutateur
  • Nous avons montré que C# permet une écriture concise pour ces deux familles importantes de services, soit les propriétés, et nous avons indiqué qu'il s'agit d'une pratique idiomatique dans ce langage, donc d'une pratique que nous allons mettre en application même si elle est plus « décorative » que nécessaire
  • Nous avons abordé très sommairement le mot static, qui en C# a le sens de « membre de classe » alors qu'un membre qui n'est pas qualifié static est un « membre d'instance »
// ...
Triangle t = new(5, 'A');
t.Dessiner();
// ...
    ... affichera à la console la chose suivante :
    A
   AAA
  AAAAA
 AAAAAAA
AAAAAAAAA

À titre de « petit bonbon », nous avons vu en début de séance que les fonctions qui se limitent à un seul return peuvent être écrites de manière simplifiée, et nous avons appris que votre chic prof, souhaitant vous encourager à écrire de courtes fonctions qui font une et une seule chose (et le font bien!), acceptera cette syntaxe si elle est bien utilisée.

Ainsi, ceci :

static int Carré(int n)
{
   return n * n;
}

... peut s'écrire de manière équivalente sous la forme suivante :

static int Carré(int n) => n * n;

... alors que ceci :

class Nom
{
   const string NOM_DÉFAUT = "Inconnu(e)";
   string valeur;
   public string Valeur
   {
      get
      {
         return valeur;
      }
      private set
      {
         if (value != null && value.Length > 0)
         {
            valeur = value;
         }
         else
         {
            valeur = NOM_DÉFAUT;
         }
      }
   }
   public string Crié
   {
      get
      {
         return Valeur.ToUpper();
      }
   }
   public Nom(string valeur)
   {
      Valeur = valeur;
   }
}

... pourra s'écrire comme suit 

class Nom
{
   const string NOM_DÉFAUT = "Inconnu(e)";
   string valeur;
   public string Valeur
   {
      get => valeur;
      private set
      {
         if (value != null && value.Length > 0)
         {
            valeur = value;
         }
         else
         {
            valeur = NOM_DÉFAUT;
         }
      }
   }
   public string Crié => Valeur.ToUpper(); // note : un get seulement, pas de set
   public Nom(string valeur)
   {
      Valeur = valeur;
   }
}

D'autres simplifications d'écriture viendront plus tard dans la session.

Quelques nouveaux termes de vocabulaire utilisés aujourd'hui : classe, instance, attribut d'instance, propriété d'instance (avec volets get, set et init), constructeur par défaut, constructeur paramétrique, qualifications d'accès private et public (il y en a d'autres), encapsulation (à peine), membre d'instance (non-static), membre de classe : static, invariant, précondition et postcondition... Ouf!

29 et 30 janvier

S01

Au menu :

  • Poursuite de la mise en place du vocabulaire de base de la POO, mais sous forme d'un survol seulement, et avec accent sur l'encapsulation. Ainsi, nous avons identifié et situé les termes et idées suivant(e)s :
    • Respect des invariants, entre chaque appel d'un service d'un objet
    • Identification et garantie du respect des préconditions pour les services d'un objet
    • Identification et garantie du respect des postconditions pour les services d'un objet
    • Rappel d'une maxime importante : « un objet est responsable de son intégrité, du début à la fin de sa vie »
  • Petite séance de programmation collective. Écrivons ensemble un programme qui :
    • Lit un nombre de personnes. Ce nombre doit être un entier strictement positif
    • Pour chaque personne :
      • lit son nom, qui devra être une chaîne de caractères non-vide
      • lit son âge (un entier positif, donc supérieur ou égal à zéro)
      • crée une Personne ayant ce nom et cet âge
      • l'ajoute dans un tableau
  • Une fois toutes les personnes lues, ce programme :
    • Trouvera et affichera le nom de la personne dont le nom est le plus long
    • Affichera l'âge moyen des personnes
  • Pour y arriver, nous définirons une classe Personne telle que :
    • Une Personne aura un nom et un âge
    • Le nom d'une Personne ne pourra être vide. Par défaut, nous utiliserons le nom "INCONNU(E)"
    • L'âge d'une Personne devra se situer entre 0 et 140 inclusivement. Par défaut, nous considérerons qu'une Personne est d'âge zéro

À titre de simplification (et de bonbon de fin de séance), j'ai aussi montré :

  • Comment utiliser foreach dans le cas où une répétitive doit itérer sur tous les éléments d'une séquence et n'a pas besoin de la valeur des indices
  • Comment utiliser l'opérateur ternaire dans les cas où nous souhaitons choisir l'une de deux expressions de même type sur la base d'une condition
  • Comment faire des propriétés automatiques, dans les cas où une classe n'a pas d'invariant garantir
  • J'ai même glissé un (très!) bref mot sur un thème qui nous occupera sous peu, soit celui des exceptions...

Quelques nouveaux termes de vocabulaire utilisés aujourd'hui : invariant, précondition et postcondition

Une solution possible est disponible ici.

31 janvier et 1 février

S02

Au menu :

  • Que faire pour signaler qu'une fonction ne pourra pas rencontrer ses postconditions : introduction (très brève) aux exceptions, un sujet important que nous couvrirons bientôt, et au mot clé throw
  • Présentation du labo 00 – Le cryptographe
  • Travail sur le labo 00 – Le cryptographe

Quelques trucs pour vous aider...

Si vous cherchez un exemple simpliste de programme de test interactif, vous pouvez utiliser celui-ci (vous pouvez aussi vous en écrire un plus à votre goût; je ne ramasserai que la classe Crypteur après tout) :

// ...
do
{
   Console.Write("Message à chiffrer? ");
   string texte = Console.ReadLine();
   Console.Write("Clé de chiffrement? ");
   int cléChiffrement = int.Parse(Console.ReadLine());
   Crypteur crypteur = new (texte, cléChiffrement);
   Console.Write("Clé à utiliser pour déchiffrer? ");
   int cléDéchiffrement = int.Parse(Console.ReadLine());
   Console.WriteLine($"Message \"déchiffré\" : {crypteur.Déchiffrer(cléDéchiffrement)}");
}
while (Poursuivre());
// ...

... notez que je suppose que vous pouvez écrire la fonction Poursuivre puisque nous l'avons fait à quelques reprises cet automne.

Si vous souhaitez transformer une string en char[], examinez les méthodes d'instance de cette string (portez attention en particulier à celles dont le nom commence par To...).

Si vous souhaitez transformer une string en majuscules, examinez les méthodes d'instance de cette string (portez attention en particulier à celles dont le nom commence par To...).

Si vous souhaitez transformer un char[] en string, sachez que string expose un constructeur paramétrique acceptant un char[] en paramètre. Par exemple, comparez les deux exemples ci-dessous (l'un des deux est plus pertinent que l'autre pour vos fins) :

// ...
char [] cs = { 'a', 'l', 'l', 'o' };
string s = cs.ToString();
Console.Write(s);
// ...
// ...
char [] cs = { 'a', 'l', 'l', 'o' };
string s = new string(cs);
Console.Write(s);
// ...

Si vous souhaitez modifier un char, alors... que diriez-vous de la simple arithmétique? Par exemple :

// ...
char c = 'A';
Console.WriteLine(c); // A
c = (char)(c + 3);
Console.WriteLine(c); // D
// ...

5 et 6 février

S03

Au menu :

  • Comment demander de l'aide
  • Comment convertir un objet en string, et pourquoi, si tabChar est un char[], l'expression tabChar.ToString() ne donne pas le même résultat que l'expression new string(tabChar) (note : nous y reviendrons)
  • Les exceptions, qui permettent entre autres de découpler la détection d'une situation atypique (une erreur, dans la grande majorité des cas) de son traitement. Plus en détail :
    • Pourquoi distinguer le moment / le lieu où un problème est détecté du moment / du lieu où il est traité (le cas échéant)
    • Trois mots clés : throw (signaler une situation exceptionelle), try (exécuter du code à risque, avec pour objectif de réagir si un problème survient), catch (gérer la situation signalée)
      • Un quatrième mot, finally, est très important (plus que catch!), mais nous y reviendrons
    • Exceptions et préconditions
    • Exceptions et postconditions
    • Exceptions et respect des invariants
    • Exceptions et constructeurs
  • Définir un type d'exception « maison »
    • Introduction à la syntaxe (qui, en C#, implique l'héritage d'implémentation, sujet que nous ne ferons qu'effleurer aujourd'hui)
  • Revisiter des exemples vus précédemment à la lueur de la matière d'aujourd'hui
  • De plus :
    • jasette informelle sur le choix d'une université (c'est le temps des portes ouvertes!)
    • mesurer l'impact en temps de levées d'exceptions
    • mesurer l'impact en temps d'ajouter un caractère à une string
    • pourquoi le type string est immuable en C#
    • pour celles et ceux qui ne l'ont pas vu la session précédente : la méthode TryParse

S'il reste du temps :

  • Travail sur le labo 00 – Le cryptographe

Le code proposé aujourd'hui était :

  • Exemple de division entière avec levée d'exception :
bool ok = false;
do
{
   try
   {
      Console.Write("Numérateur ?  ");
      int num = int.Parse(Console.ReadLine());
      Console.Write("Dénominateur? ");
      int denom = int.Parse(Console.ReadLine());
      Console.WriteLine($"{num} / {denom} == {DivisionEntière(num, denom)}");
      ok = true;
   }
   catch(FormatException)
   {
      Console.WriteLine("Oups, je refuse (pas un entier); on réessaie");
   }
   catch (DivisionParZéroException)
   {
      Console.WriteLine("Oups, je refuse (dénominateur nul); on réessaie");
   }
}
while (!ok);

// précondition : dénominateur != 0
// postcondition : retourne le quotient du numérateur par le dénominateur
// exception : la fonction ne peut pas satisfaire ses postconditions
//             (en gros, elle ne peut pas faire son travail)
static int DivisionEntière(int numérateur, int dénominateur)
{
   if(dénominateur == 0)
   {
      throw new DivisionParZéroException();
   }
   return numérateur / dénominateur;
}

class DivisionParZéroException : Exception { }
  • Mesurer le coût en temps de levées d'exceptions :
const int N = 300_000_000;
System.Diagnostics.Stopwatch sw = new();

int[] tab = CréerTableau(N);

sw.Start();
int combien = CompterImpairsPositifs(tab);
sw.Stop();
Console.WriteLine($"Compté {combien} impairs positifs et {sw.ElapsedMilliseconds} ms");


static bool EstImpairPositif(int n)
{
   if (n < 0)
   {
      throw new ZutException();
   }
   return n % 2 != 0;
}
static int CompterImpairsPositifs(int[] tab)
{
   int n = 0;
   foreach (int nb in tab)
   {
      try
      {
         if (EstImpairPositif(nb))
         {
            ++n;
         }
      }
      catch (ZutException)
      {
      }
   }
   return n;
}

static int[] CréerTableau(int n)
{
   int[] tab = new int[n];
   for (int i = 0; i != n; ++i)
   {
      tab[i] = i % 10 == 0 ? -(2 * i + 1) : 2 * i + 1;
   }
   return tab;
}

class ZutException : Exception { }
  • Mesurer le coût en temps d'ajout naïf de caractères à une string (rappel : en C#, les instances de string sont immuables, ce qui fait que l'expression s += c est équivalente à s = new string(...texte de s + caractère c...) ce qui crée à chaque itération une string plus grande que la précédente... Ouf!
System.Diagnostics.Stopwatch sw = new();
const int N = 10_000_000;

for(int i = 1; i <= N; i *= 10)
{
   sw.Start();
   string s = CréerChaîne(i, 'S');
   sw.Stop();
   Console.WriteLine($"Créé string de {s.Length} caractères en {sw.ElapsedMilliseconds} ms");
}

static string CréerChaîne(int n, char c)
{
   string s = "";
   for(int i = 0; i != n; ++i)
   {
      s += c;
   }
   return s;
}

Quelques exemples complémentaires, si ça vous intéresse :

  • Exemple de classe Cercle avec invariant sur le Rayon :
Cercle c0 = LireCercle();
Afficher(c0);

static void Afficher(Cercle c)
{
   Console.WriteLine($"Centre : {c.Centre.X},{c.Centre.Y}, rayon : {c.Rayon}");
}

static Point LirePoint()
{
   Console.Write("X? ");
   int x = int.Parse(Console.ReadLine());
   Console.Write("Y? ");
   int y = int.Parse(Console.ReadLine());
   return new(x, y);
}
static Cercle LireCercle()
{
   Cercle cercle = null;
   do
   {
      Point centre = LirePoint();
      Console.Write("Rayon? ");
      float rayon = float.Parse(Console.ReadLine());
      try
      {
         cercle = new(centre, rayon);
      }
      catch(RayonInvalideException)
      {
         Console.WriteLine("Rayon invalide, on recommence");
      }
   }
   while (cercle == null);
   return cercle;
}

class Point
{
   public int X { get; init; }
   public int Y { get; init; }
   public Point()
   {
      X = 0;
      Y = 0;
   }
   public Point(int x, int y)
   {
      X = x;
      Y = y;
   }
}

class RayonInvalideException : Exception { }

// invariant : Rayon > 0
class Cercle
{
   public Point Centre { get; init; }
   private float rayon;
   public float Rayon
   {
      get => rayon;
      set
      {
         if(value <= 0)
         {
            throw new RayonInvalideException();
         }
         rayon = value;
      }
   }
   public Cercle()
   {
      Centre = new();
      Rayon = 1.0f;
   }
   public Cercle(Point centre, float rayon)
   {
      Centre = centre;
      Rayon = rayon;
   }
}
  • Exemple (simpliste) de manipulation de chaînes de caractères :
string s = "J'aime mon prof";
Console.WriteLine(s);
s = s.ToUpper();
Console.WriteLine(s);
//for(int i = 0; i != s.Length; ++i)
//{
//   Console.Write($"{s[i]} ");
//}
foreach (char c in s)
{
   Console.Write($"{c} ");
}
Console.WriteLine();
char[] tab = s.ToCharArray();
for (int i = 0; i != tab.Length; ++i)
{
   if (char.IsWhiteSpace(tab[i]))
   {
      tab[i] = '#';
   }
}
// notez la différence entre les deux conversions ci-dessous...
s = new string(tab);
Console.WriteLine(s);
s = tab.ToString();
Console.WriteLine(s);

7 et 8 février

S04

Au menu :

  • Dernière séance pour fignoler le labo 00. C'est le moment idéal pour :
    • Vous assurer de respecter les consignes (relisez-les avec attention!)
    • Tester les cas limites (p. ex. : chiffrer une chaîne vide n'est pas une erreur... Ça donne simplement une autre chaîne vide!)
    • Si vous ne l'avez pas encore fait, vous pouvez essayer les tests proposés dans l'énoncé... Si vous ne passez pas tous les tests, c'est qu'il vous reste encore au moins un bogue (et si vous passez tous les tests, ça ne veut pas dire que le code est propre! 🙂)

Vous pouvez aussi essayer le programme de test suivant (ajouter le using requis pour que votre Crypteur soit accessible) :

/// Programme client de tests pour le laboratoire 00
/// classe Crypteur - Hiver 2024
/// 
/// par Vincent Echelard, 2013
/// révisé et amélioré par Pierre Prud'homme, février 2022
/// Ajusté et mis à jour par Patrice Roy, février 2023
/// --------------------------------------------------------------------
using System;

Console.SetWindowSize(Console.LargestWindowWidth, Console.LargestWindowHeight);
Console.SetWindowPosition(0,0);
Console.BackgroundColor = ConsoleColor.White;
Console.ForegroundColor = ConsoleColor.DarkBlue;
Console.Clear();

const int NB_TESTS = 10;
Console.Write("Nom de l'étudiant(e) : ");
string s = Console.ReadLine();
Console.WriteLine(new string('-', 72));

int résultatDesTests = 0;
résultatDesTests += Tester("ALLO", 2, "CNNQ", "Test simple (majuscules)");
résultatDesTests += Tester("Allo", 2, "CNNQ", "Test simple (majuscule/minuscules)");
résultatDesTests += Tester("allo", 2, "CNNQ", "Test simple (minuscules)");
résultatDesTests += Tester("allo", -2, "CNNQ", "Test clef négative (chiffrement)");
résultatDesTests += Tester("ALLO", 1328, "CNNQ", "Test clef très grande (chiffrement)");
résultatDesTests += Tester("Veux-tu 1 café?", 2, "XGWZ-VW 1 ECHÉ?", "Test caractères non-alphabétique (chiffrement)");
// oui, il y a une faute dans la phrase suivante, je sais
résultatDesTests += Tester("Zorglub veux 1 café!", -1332, "FUXMRAH BKAD 1 IGLÉ!", "Test complet (chiffrement)");
résultatDesTests += Tester("Élu par cette crapule", 27, "ÉMV QBS DFUUF DSBQVMF", "Test décalage +1");
résultatDesTests += Tester("Élu par cette crapule", 26, "ÉLU PAR CETTE CRAPULE", "Test de chiffrement sans effet");
résultatDesTests += Tester("élu par cette crapule", 25, "ÉKT OZQ BDSSD BQZOTKD", "Test décalage -1");
Console.Write($"A eu : {résultatDesTests} / {NB_TESTS}");
Console.ReadKey();

static int Tester(string messageÀCrypter, int clefDeChiffrement,
                  string messageCrypté, string nomDuTest)
{
   string espacement = new string(' ', 13);
   int résultatDuTest = 0;
   Crypteur objTest = null;

   try
   {
      objTest = new Crypteur(messageÀCrypter, clefDeChiffrement);
      if (objTest.MessageSecret == messageCrypté)
      {
         résultatDuTest = 1;
         Console.WriteLine($"Réussite --> {nomDuTest} " + 
                           $"Msg à crypter: {messageÀCrypter} - " +
                           $"Clef: {clefDeChiffrement}  " + Environment.NewLine +
                           $"{espacement}Prévu:{messageCrypté} - Obtenu:{objTest.MessageSecret} " + Environment.NewLine);
      }
      else
      {
         Console.WriteLine($"ÉCHEC    --> {nomDuTest} " +
                           $"Msg à crypter: {messageÀCrypter} - " +
                           $"Clef: {clefDeChiffrement}  " + Environment.NewLine +
                           $"{espacement}Prévu:{messageCrypté} - Obtenu:{objTest.MessageSecret} " + Environment.NewLine);
      }
   }
   catch (Exception e)
   {
      Console.WriteLine($"Erreur lors du test " + nomDuTest + " : " + e.Message);
      if (objTest != null)
      {
         Console.WriteLine($"Msg à crypter : {messageÀCrypter}  - Clef : {clefDeChiffrement}   -- Msg obtenu : {objTest.MessageSecret}");
      }
   }
   return résultatDuTest;
}

Pour le reste : des exercices, des exercices, et des exercices!

Exercice 1a

Soit une classe représentant un point de l'espace 2D. Chaque instance de cette classe :

  • Comporte deux attributs « réels » : un x et un y
  • Donne accès en lecture aux valeurs de x et y par le moyen d'une propriété X et Y respectivement
  • Donne accès en écriture aux valeurs de x et de y par le moyen des propriétés X et Y sans les valider puisque toute valeur est acceptable
  • Comporte un constructeur paramétrique qui s'assure que l'instance en création est dans un état valide
  • Comporte un constructeur par défaut
  • Offre une fonction pour calculer la distance entre deux points

Travail à réaliser :

  • En précisant leur qualificateur d'accès, et en précisant s'il s'agit de membres d'instance (non-static) ou de membres de classe (static) :
    • Dressez la liste des attributs de cette classe
    • Dressez la liste des méthodes de cette classe
    • Dressez la liste des propriétés de cette classe
  • Rédigez cette classe et testez-la à l'aide du code client disponible sur le site Web du cours.

Exercice 1b

Soit une classe représentant un point du quadrant 1 de l'espace 2D. Chaque instance de cette classe :

  • Comporte deux attributs « réels » : un x et un y
  • Donne accès en lecture aux valeurs de x et y par le moyen d'une propriété X et Y respectivement
  • Donne accès en écriture aux valeurs de x et de y par le moyen des propriétés X et Y en validant que la valeur est valide pour le quadrant 1
  • Comporte un constructeur paramétrique qui s'assure que l'instance en création est dans un état valide

En cas d'erreur du programme client dans l'utilisation d'une instance de cette classe, la classe doit lever une exception :

  • Dans le cas où le code client tenterait de mettre une valeur négative en X, votre classe devra lever une exception de type CoordonnéeXInvalideException
  • Dans le cas où le code client tenterait de mettre une valeur négative en Y, votre classe devra lever une exception de type CoordonnéeYInvalideException

Travail à réaliser :

  • En précisant leur qualificateur d'accès, et en précisant s'il s'agit de membres d'instance (non-static) ou de membres de classe (static) :
    • Dressez la liste des attributs de cette classe
    • Dressez la liste des méthodes de cette classe
    • Dressez la liste des propriétés de cette classe
  • Rédigez cette classe et testez-la à l'aide du code client disponible sur le site Web du cours.

Exercice 2

Soit une classe représentant un compte bancaire (très simple). Les instances de cette classe devront offrir les services suivants :

  • Une propriété Solde permettant d'en connaître le solde
  • Une méthode Déposer permettant d'effectuer un dépôt
  • Une méthode Retirer permettant d'effectuer un retrait
  • Un constructeur par défaut
  • Un constructeur paramétrique permettant de préciser le solde initial du compte

Vous devez faire en sorte que par défaut, ce compte bancaire soit créé avec un solde à zéro; si le constructeur paramétrique est utilisé, la valeur précisée lors du processus d'instanciation doit être positive ou égale à 0.

Les méthodes permettant d'effectuer les dépôts et les retraits recevront en paramètre le montant à déposer ou à retirer selon le cas, qui doit être un entier positif strictement plus grand que 0, et ne retourneront rien.

Ce type de compte bancaire a un invariant : il ne pourra à aucun moment avoir un solde négatif. En vertu de l'encapsulation, vous devez vous assurer du respect de cet invariant, donc faire en sorte qu'en tout temps votre objet reste valide.

Dans le cas où le code client tenterait de créer une instance en y attribuant un solde négatif, votre classe devra lever une exception de type SoldeInvalideException.

Dans le cas où le code client tenterait de retirer un montant supérieur au solde du compte, ou encore de déposer un montant négatif ou nul, votre objet devra évidemment refuser l'opération et lever une exception de type OpérationInvalideException.

Travail à réaliser :

  • En précisant leur qualificateur d'accès, et en précisant s'il s'agit de membres d'instance (non-static) ou de membres de classe (static) :
    • Dressez la liste des attributs de cette classe
    • Dressez la liste des méthodes de cette classe
    • Dressez la liste des propriétés de cette classe
  • Rédigez cette classe et testez-la.

Une solution possible serait ceci : ClasseCompteBancaire.html

Exercice 3

Plus difficile, car moins directif. Vous développez un jeu impliquant des héros et des monstres. Les règles sont les suivantes :

  • Tout héros a des points de vie, représentés par un nombre entier
  • Tout héros a un nom
  • Tout monstre a des points de vie, représentés par un nombre entier
  • Tout monstre a un nom
  • Le nom d'un monstre doit être d'une longueur maximale de cinq caractères, et ne doit contenir que des consonnes
  • À la construction, un héros a un nombre de points de vie choisi aléatoirement entre 50 et 100 inclusivement
  • À la construction, un monstre a un nombre de points de vie indiqué par un paramètre passé au constructeur
  • Tout héros a une force, un entier dont la valeur est indiquée par un paramètre passé à la construction. Cette valeur doit être entre 10 et 20 inclusivement
  • Un héros peut frapper un autre personnage. Ceci blessera ce personnage en réduisant ses points de vie par une valeur pseudoaléatoire entre et de la force du héros
  • Tout monstre a une force, un entier dont la valeur est indiquée par un paramètre passé à la construction. Cette valeur doit être entre 15 et 25 inclusivement
  • Un monstre peut frapper un autre personnage. Ceci blessera ce personnage en réduisant ses points de vie par une valeur pseudoaléatoire entre et de la force du monstre
  • Un héros est un personnage
  • Un monstre est un personnage
  • Si les points de vie d'un personnage sont inférieurs ou égaux à zéro, alors ce personnage est mort, sinon il est vivant

Travail à réaliser :

  • Rédigez les classes Héros et Monstre
  • Identifiez ce qu'elles ont en commun et placez ces attributs, propriétés et méthodes dans une classe Personnage qui leur servira toutes deux de parent
  • Identifiez les attributs, propriétés, méthodes et constructeurs de chacune des classes que vous envisagez
  • Écrivez un petit programme de test représentant un combat entre un Héros et un Monstre et faisant la démonstration que votre design fonctionne, et respecte les consignes

Exercice 4

Sachant que la couleur de l'affichage de texte dans un écran console est donnée par la propriété Console.ForegroundColor, et sachant qu'il est possible de positionner le curseur où l'affichage de texte se fera à l'aide de la méthode Console.SetCursorPosition, écrivez une classe Carré telle que :

  • Un Carré a une position décrite par un point 2D
    • Note : à l'écran console, le point est le coin en haut et à gauche de l'écran, et les coordonnées en et en sont positives vers la droite et vers le bas respectivement
  • Un Carré a une longueur de côté
  • Un Carré a une couleur, de type ConsoleColor
  • Les caractéristiques d'une instance de Carré sont déterminées à la construction de cet objet
  • Dessiner un Carré dessinera ce carré à la position choisie, de la taille choisie, et à la couleur choisie

Travail à réaliser :

  • Rédigez la classe Carré
  • Identifiez les attributs, propriétés, méthodes et constructeurs de cette classe
  • Écrivez un programme de test dans lequel on trouvera un tableau de références sur des Carré et qui, en itérant à travers ce tableau, affichera ces divers objets à l'écran

12 et 13 février

S05

Au menu :

  • Quelques exercices choisis de S04
    • Nous avons investi principalement du temps sur l'exercice 3 (une variante du code vu en classe est disponible ici; notez qu'elle ne comprend pas la méthode Frapper, pas plus que le code de test)
  • L'héritage d'implémentation (dans le respect des limites de C#), effleuré seulement, par lequel une classe peut être une spécialisation d'une autre
    • Relation entre parent et enfant
    • Impact des qualifications private et public
    • Héritage et construction
    • Le mot clé base (introduction)

14 et 15 février

S06

Au menu :

  • Finir l'exercice 3 de S04
    • Le problème de la méthode Frapper
    • Qualification protected
  • Parler de soi : le mot clé this
    • Constructeurs de délégation
  • Discussion de quelques relations entre classes
    • Héritage d'implémentation
    • Composition
    • Agrégation
    • Association
    • Sens de chacun
  • Quelle relation privilégier quand plusieurs sont possibles
    • Idée de couplage
    • Idée de cohésion
  • Faire l'exercice 4 de S04

Le code auquel nous sommes arrivé(e)s pour l'exercice 3 de la séance S04 est disponible ici

Le code auquel nous sommes arrivé(e)s pour l'exercice 4 de la séance S04 est disponible ici

Pour les éléments de vocabulaire quant aux relations, informellement, ce que nous avons relevé est :

  • Héritage d'implémentation : verbe être
    • Un Héros est un Personnage
    • Les membres publics (et protégés) du parent (Personnage) sont accessibles pour l'enfant (Héros)
    • En C#, un enfant parle de sa partie parent avec le mot base
    • On peut traiter un enfant comme un cas particulier de son parent (ici : si une fonction prend un Personnage en paramètre, je peux lui passer un Héros)
    • Quand on construit un enfant, il faut d'abord construire la partie parent
  • Composition : verbe avoir
    • Un objet contient d'autres objets
    • Une voiture contient un moteur (mettons)
    • Un objet est composé d'autres objets
    • L'objet contenu a une vie délimitée par l'objet qui le contient
  • Agrégation : verbe avoir / utiliser
    • Un peu comme la composition
    • L'objet « contenu » a une vie qui peut chevaucher celle de l'objet qui le « contient »
    • Pensez à des pneus dans une voiture
  • Association :
    • Deux objets se connaissent, et peuvent se parler
  • On veut : faible couplage, forte cohésion
    • Quand on a des choix, on vise les relations au plus faible couplage possible
    • Couplage des relations ci-dessus, du plus fort au plus faible :
      • Héritage d'implémentation
      • Agrégation / composition
      • Association
  • Couplage
    • Essayer d'isoler les changements pour qu'ils aient un impact le plus local possible
    • Plus les trucs sont locaux, mieux c'est (p.ex. : variable locale)
    • Plus les trucs sont privés, mieux c'est
  • Cohésion
    • « Les trucs qui vont ensemble... vont ensemble »

Pour vous faire pratiquer...

  • Petit quiz de vocabulaire. Soit le code ci-dessous :
using System;

// ... programme principal (omis par simplicité)


class ContientBlancsException : Exception { }
class MotVideException : Exception { }
class Mot
{
   private string valeur;
   public string Valeur
   {
      get => valeur;
      private set
      {
         if (value == null || value.Length == 0)
            throw new MotVideException();
         if (Contient(value.ToCharArray(), ' '))
            throw new ContientBlancsException();
         valeur = value.ToLower();
      }
   }
   public int Longueur => Valeur.Length;
   public Mot(string valeur)
   {
      Valeur = valeur;
   }
   private static char[] ObtenirVoyelles() => new char[] { 'a', 'e', 'i', 'o', 'u', 'y' };
   public int NbVoyelles => CompterOccurrences(Valeur, ObtenirVoyelles());
   public int NbConsonnes => Longueur - NbVoyelles;
   private static bool Contient(char [] cs, char c)
   {
      for(int i = 0; i != cs.Length; ++i)
         if (cs[i] == c)
            return true;
      return false;
   }
   private static int CompterOccurrences(string chaîne, char [] caractères)
   {
      int n = 0;
      foreach(char c in chaîne)
         if (Contient(caractères, c))
            ++n;
      return n;
   }
   private static int TrouverPremièreDifférence(string s0, string s1)
   {
      int plusPetit = Math.Min(s0.Length, s1.Length);
      int i = 0;
      while (i != plusPetit && s0[i] == s1[i])
      {
         ++i;
      }
      return i;
   }
   public bool Précède(Mot autre)
   {
      int pos = TrouverPremièreDifférence(Valeur, autre.Valeur);
      return pos == Math.Min(Longueur, autre.Longueur) ? Longueur < autre.Longueur : Valeur[pos] < autre.Valeur[pos];
   }
}

Répondez aux questions suivantes :

  • Que représente une instance de la classe Mot? Soyez aussi précise ou précis que possible
  • Quelles sont les règles qui assurent la validité d'un Mot? Soyez aussi précise ou précis que possible
  • Quelles sont les méthodes d'instance de la classe Mot? (listez leurs noms seulement)
  • Quelles sont les méthodes de classe de la classe Mot? (listez leurs noms seulement)
  • Quelles sont les propriétés d'une instance de la classe Mot? (listez leurs noms seulement)
  • Quels sont les attributs d'une instance de la classe Mot? (listez leurs noms seulement)
  • Dans un programme principal de votre cru, créez deux instances m0 et m1 de Mot avec des chaînes de caractères valides et distinctes l'une de l'autre, puis appelez la méthode Précède correctement pour ensuite afficher laquelle de ces deux instances de Mot apparaîtrait en premier dans un dictionnaire
  • Est-ce que NbConsonnes donnerait la bonne valeur pour un Mot créé de la manière suivante : new Mot("plate-forme")? Expliquez votre réponse
  • Est-ce que NbVoyelles donnerait la bonne valeur pour un Mot créé de la manière suivante : new Mot("Yogourt") ? Expliquez votre réponse

À titre de solutionnaire pour cet exercice :

  • Une instance de la classe Mot représente une chaîne de caractères non-nulle et non-vide, ne contenant que des lettres minuscules et exempte du caractère ' '
  • Un Mot est toujours valide, car son constructeur (et ses propriétés) le garantissent. Cela dit, une string utilisée pour construire un Mot est acceptable si elle est non-nulle, non-vide et est exempte du caractère ' '. Notez que cette string peut contenir d'autres caractères que des lettres minuscules, car la transformation en minuscules est faite par l'instance de Mot elle-même
  • La classe Mot a les méthodes d'instance suivantes : Précède et (à la limite) le constructeur paramétrique

À titre de rappel, une méthode d'instance est une fonction membre non-static

  • La classe Mot a les méthodes de classe suivantes :
    • ObtenirVoyelles
    • Contient
    • CompterOccurrences
    • TrouverPremièreDifférence

À titre de rappel, une méthode de classe est une fonction membre static

  • La classe Mot a les propriétés d'instance suivantes :
    • Valeur
    • Longueur
    • NbVoyelles
    • NbConsonnes

À titre de rappel, une propriété d'instance est une pseudo-variable membre non-static offrant un contrôle d'accès en lecture (get) ou en écriture (set, init)... ou les deux

  • La classe Mot a l'attribut d'instance suivant : valeur

À titre de rappel, un attribut d'instance est variable membre non-static

  • Pour la question suivante : « Dans Main, créez deux instances m0 et m1 de Mot avec des chaînes de caractères valides et distinctes l'une de l'autre, puis appelez la méthode Précède correctement pour ensuite afficher laquelle de ces deux instances de Mot apparaîtrait en premier dans un dictionnaire », une solution possible serait :
// ...
static void Main()
{
   Mot m0 = new Mot(Console.ReadLine()); // n'entrez pas d'espace!
   Mot m1 = new Mot(Console.ReadLine()); // n'entrez pas d'espace non plus!
   if(m0.Précède(m1))
   {
      Console.WriteLine($"{m0.Valeur} précède {m1.Valeur}");
   }
   else
   {
      Console.WriteLine($"{m1.Valeur} précède {m0.Valeur}");
   }
}
  • Pour la question suivante : « Est-ce que NbConsonnes donnerait la bonne valeur pour un Mot créé de la manière suivante : new Mot("plate-forme")? », la réponse est non, car le mot contient un '-' et la propriété NbConsonnes comptera ce caractère comme une consonne (c'est un bogue qu'il faudrait corriger)
  • Pour la question suivante : « Est-ce que NbVoyelles donnerait la bonne valeur pour un Mot créé de la manière suivante : new Mot("Yogourt") ? », la réponse est oui car, même si les voyelles considérées sont toutes minuscules alors que le 'Y' de "Yogourt" est majuscule, le set de la propriété Valeur transforme la chaîne en minuscules avant de la déposer dans l'attribut valeur

19 et 20 février

S07

Au menu :

  • Retour sur le labo 00
    • Regard plus spécifique sur le découpage
    • Regard plus spécifique sur le nommage
  • Retour sur le petit quiz de vocabulaire de S06
  • Petit tour d'horizon de la classe string
  • Comparatif de vitesse avec StringBuilder
  • Quand utiliser string et quand utiliser StringBuilder
  • Profiter des membres de classe dans le code client
  • Présentation du labo 01
  • Travail sur le labo 01

21 et 22 février

S08

Au menu :

  • Classes statiques
    • Petit allègement syntaxique sympathique
  • Un Carré est-il un Rectangle?

Notre petit exemple était :

Rectangle r = new(10, 4);
Console.WriteLine($"Rectangle de {r.Hauteur} x {r.Largeur}");
Console.WriteLine($"Aire : {r.Aire}, périmètre : {r.Périmètre}");
r.Dessiner();
Carré c = new(5);
Console.WriteLine($"Carré de {c.Hauteur} x {c.Largeur}");
Console.WriteLine($"Aire : {c.Aire}, périmètre : {c.Périmètre}");
c.Dessiner();

Vilaine(c);
Console.WriteLine($"Carré de {c.Hauteur} x {c.Largeur}");
Console.WriteLine($"Aire : {c.Aire}, périmètre : {c.Périmètre}");
c.Dessiner();

static void Vilaine(Rectangle r)
{
   r.Largeur *= 2;
}

class Rectangle
{
   public int Périmètre => 2 * (Hauteur + Largeur);
   public int Aire => Hauteur * Largeur;
   public int Hauteur { get; set; }
   public int Largeur { get; set; }
   public Rectangle(int hau, int lar)
   {
      Hauteur = hau;
      Largeur = lar;
   }
   public void Dessiner()
   {
      for(int ligne = 0; ligne != Hauteur; ++ligne)
      {
         for(int col = 0; col != Largeur; ++col)
            Console.Write('#');
         Console.WriteLine();
      }
   }
}

class Carré : Rectangle
{
   public int Hauteur
   {
      get => base.Hauteur;
      set
      {
         base.Hauteur = value;
         base.Largeur = value;
      }
   }
   public int Largeur
   {
      get => base.Largeur;
      set
      {
         base.Hauteur = value;
         base.Largeur = value;
      }
   }
   public Carré(int côté) : base(côté, côté)
   {
   }
}
  • Premier coup d'oeil sur une classe très utile : la classe List<T> qui modélise un tableau dynamique

Petit exemple avec un List<T>  T est int :

  • Créer une List<int> vide
  • Ajouter des valeurs dans une List<int>
  • Créer une List<int> avec des valeurs initiales
  • Parcourir une List<int> (for, foreach)
  • Trier une List<int>

Par exemple :

using System;
using System.Collections.Generic;

// alternative : List<int> lst = new() { 3,7,11,2,5 };
List<int> lst = new();
foreach(int n in new[]{ 3, 7, 11, 2, 5 })
   lst.Add(n);
// parcourir avec foreach
foreach(int n in lst)
   Console.Write($"{n} ");
Console.WriteLine();
// parcourir avec for
for(int i = 0; i != lst.Count; ++i)
   Console.Write($"{lst[i]} ");
Console.WriteLine();
// trier les éléments en ordre croissant
lst.Sort();
// etc.
  • Un TiTableau est-il un List<T>?
  • Très brève introduction au polymorphisme, un sujet riche sur lequel nous reviendrons...

Notre petit exemple introductoire était :

Jim jim = new("Tremblay");
jim.Présenter();
Joe joe = new("Biden");
joe.Présenter();
Bob bob = new("Nguyen");
bob.Présenter();

Personne[] p = new Personne[] { jim, joe, bob };
foreach (Personne pers in p)
   pers.Présenter();

class Personne
{
   public string Nom { get; init; }
   public Personne(string nom)
   {
      Nom = nom;
   }
   public virtual void Présenter()
   {
      Console.WriteLine($"Mon nom est {Nom}");
   }
}
class Jim : Personne
{
   public Jim(string nom) : base(nom) { }
   public override void Présenter()
   {
      Console.WriteLine($"Mon nom est Jim {Nom}");
   }
}
class Joe : Personne
{
   public Joe(string nom) : base(nom) { }
   public override void Présenter()
   {
      Console.WriteLine($"My name is Joe {Nom}");
   }
}
class Bob : Personne
{
   public Bob(string nom) : base(nom) { }
   public override void Présenter()
   {
      Console.WriteLine($"Euh... chu Bob {Nom}");
   }
}

Pour le reste, si ça vous amuse, je vous laisse ce petit cadeau...

static void AfficherBandes(Histogramme h)
{
   const int LONGUEUR_MAX = 80;
   // pourrait être une fonction
   int nbFreq = 0;
   for(int i = 0; i != h.NbIntervalles; ++i)
      nbFreq += h.GetFrequenceIntervalle(i);
   // le travail commence ici
   for (int i = 0; i != h.NbIntervalles; ++i)
   {
      int bMin = h.GetBorneMin(i),
          bMax = h.GetBorneMax(i);
      int freq = h.GetFrequenceIntervalle(i);
      Console.Write($"[{bMin,3:0},{bMax,3:0}] : ");
      var proportion = (double)h.GetFrequenceIntervalle(i) / nbFreq;
      Console.WriteLine($"{new string('#', (int)(proportion * LONGUEUR_MAX))} ({proportion * 100:F2}%)");
   }
}

... alors si ça vous amuse, tant mieux!

26 et 27 février

S09

Au menu :

  • Tri avec comparateurs (ou : comment rendre le comparateur plus charmant)
    • Qu'est-ce qu'un three-way-compare?
    • Comment l'implémenter efficacement?
  • Suivi de notre petite introduction au polymorphisme

Le chemin que nous avons suivi fut « classique » :

  • Une Forme a un Symbole
  • Un Triangle est une Forme
  • Un Triangle peut se dessiner
  • Un Rectangle est une Forme
  • Un Rectangle peut se dessiner

Ce serait cool de pouvoir écrire une fonction Dessiner(Forme f) qui (a) fait une copie de sauvegarde de la couleur du texte à l'écran, (b) la remplace par la couleur de la Forme, (c) dessine la Forme, puis (d) remet la couleur originale pour le texte à l'écran... sauf que f.Dessiner n'existe pas.

Pour résoudre ce problème, nous avons d'abord inséré une méthode Dessiner non virtuelle dans Forme, pour se rendre compte que ça ne fait rien de pertinent.

Nous avons ensuite virtual (dans la classe Forme) et override (dans les classes Triangle et Rectangle), suite à quoi l'affichage s'est mis à dessiner des trucs colorés à l'écran, pour notre plus grand bonheur!

En bout de ligne, on arrive à quelque chose comme ce qui suit. J'ai ajouté un peu de validation (note : c'est une première étape; nous raffinerons le modèle sous peu) :

using System;

Forme [] formes = new Forme[]
{
   new Rectangle('#', 30, 10),
   new Triangle('A', 7)
};
// Polymorphisme : à partir d'une abstraction (ici : Forme), on
// appelle le service de l'objet réellement pointé (p.ex. : Triangle)
foreach(Forme f in formes)
   f.Dessiner();

class Forme
{
   public char Symbole { get; private init; }
   public Forme(char symbole)
   {
      Symbole = symbole;
   }
   // méthode virtuelle : _peut_ être spécialisée par les enfants
   public void Dessiner()
   {
      // ... quoi mettre ici? on y reviendra ...
   }
}

// invariants :
// - Hauteur strictement positive
class Triangle : Forme
{
   int hauteur;
   public int Hauteur
   {
      get => hauteur;
      private init
      {
         hauteur = value > 0 ? value : throw new ArgumentException();
      }
   }
   public Triangle(char symbole, int hauteur) : base(symbole)
   {
      Hauteur = hauteur;
   }
   // override : je fais le choix explicite de spécialiser une méthode
   // d'un parent (ici : Forme.Dessiner)
   protected override void Dessiner()
   {
      for (int ligne = o; ligne != Hauteur; ++ligne)
      {
         for (int col = 0; col <= ligne; ++col)
            Console.Write(Symbole);
         Console.WriteLine();
      }
   }
}

// invariants :
// - Largeur strictement positive
// - Hauteur strictement positive
class Rectangle : Forme
{
   int largeur;
   int hauteur;
   public int Largeur
   {
      get => largeur;
      private init
      {
         largeur = value > 0 ? value : throw new ArgumentException();
      }
   }
   public int Hauteur
   {
      get => hauteur;
      private init
      {
          hauteur = value > 0 ? value : throw new ArgumentException();
      }
   }
   public Rectangle(char symbole, int largeur, int hauteur) : base(symbole)
   {
      Largeur = largeur;
      Hauteur = hauteur;
   }
   protected override void Dessiner()
   {
      for (int ligne = 0; ligne != Hauteur; ++ligne)
      {
         for (int col = 0; col != Largeur; ++col)
            Console.Write(Symbole);
         Console.WriteLine();
      }
   }
}

Résumé des « nouvelles » idées de cette partie du cours :

Héritage d'implémentation (enfant est un cas particulier du parent). Bon, c'est pas nouveau d'aujourd'hui, mais...

Polymorphisme :

  • Par une abstraction (p.ex. : le parent), on appelle le service le plus spécialisé de l'objet pointé (p.ex. : enfant)
  • virtual (l'enfant peut spécialiser la méthode)
  • override (l'enfant choisit de spécialiser le service)

Aussi : examen formatif, en vue de l'intra qui se tiendra la première semaine suivant la semaine de lecture et de récupération.

28 et 29 février

S10

Au menu :

  • On fait l'examen formatif ensemble
  • Présentation d'une petite activité pratique pour la semaine de lecture et de récupération

Activité pour la semaine de lecture et de récupération

La base de cette activité sera l'exercice 3 de S04 pour lequel une solution est disponible ici. Nous allons construire sur cette base un programme amusant (du moins, c'est le souhait!). Il se peut que vous vouliez utiliser du polymorphisme à un endroit, mais pour l'essentiel vous devriez pouvoir résoudre ce problème avec de l'héritage d'implémentation et de la composition.

  • Un Héros peut posséder une Arme. Si un Héros n'a pas d'Arme, alors son Arme sera null.
  • Une Arme peut AppliquerEffet lorsqu'un Héros frappe un autre Personnage. Par exemple, un Gourdin aura pour effet d'ajouter 3 aux dégâts causés quand un Héros frappe un Personnage alors qu'un Halebarde aura pour effet d'ajouter 8 aux dégâts dans ces circonstances.
  • Ajoutez une classe Armée qui prendra en paramètre à la construction un tableau de Héros et les entreposera d'une manière qui vous semblera pertinente. Une Armée ne peut pas être vide; elle doit contenir au moins un Héros, il s'agit d'un de ses invariants. Un autre de ses invariants est qu'elle doit contenir un nombre pair de Héros. Note : un Héros mort demeure un Héros.
  • Ajoutez une classe Horde qui prendra en paramètre à la construction un tableau de Monstre et les entreposera d'une manière qui vous semblera pertinente. Une Horde ne peut pas être vide; elle doit contenir au moins un Monstre, il s'agit d'un de ses invariants. Note : un Monstre mort demeure un Monstre.
  • Si un Armée attaque un groupe adverse de Personnage (par exemple, une Horde), alors un membre vivant de l'Armée pris au hasard frappera un de ses adversaires vivants pris au hasard. Si un Horde attaque un groupe adverse de Personnage (par exemple, une Armée), alors un membre vivant de la Horde pris au hasard frappera un de ses adversaires vivants pris au hasard.
  •  Exceptionnellement, lors d'une attaque, vous pouvez afficher à la console ce qui se passe dans le combat, p. ex.: qui attaque vers qui; combien de vie la cible de l'attaque possède avant le coup, et combien de vie la cible de l'attaque possède après le coup. J'écris « exceptionnellement » car on ne voudrait normalement pas enchevêtrer attaque et affichage, mais je souhaite que le problème à résoudre demeure relativement simple.

Un exemple de programme de test serait :

using ActivitéSemaineLecture;
using z;
//
// armée qui contiendra :
// - Bill le petit, 15 de force
// - Valentin, 18 de force
// - Galahad, 17 de force armé d'une halebarde causant un dégât supplémentaire de huit points
// - Brute immonde, 20 de force armé d'un gourdin causant un dégât supplémentaire de trois points
//
Armée armée = new(new Héros[]
{

   // ...


   new Héros("Bill le petit", 15),
   new ("Valentin", 18),
   new ("Galahad", 17, new Arme("Halebarde", 8)),
   new ("Brute immonde", 20, new Arme("Gourdin", 3))

});
//
// horde qui contiendra :
// - GRRR, 24 de force et 50 de vie
// - HSSSS, 22 de force et 44 de vie
// - BRK, 20 de force et 40 de vie
// - FFFT, 19 de force et 15 de vie
// - prkkk, 21 de force et 38 de vie
//
Horde horde = new(new Monstre[]
{

   // ...


   new("GRRR", 24, 50),
   new("HSSSS", 22, 44),
   new("BRK", 20, 40),
   new("FFFT", 19, 15),
   new("prkkk", 21, 38)

});

bool tourHéros = new Random().Next() % 2 == 0;
while (!armée.EstDéfait && !horde.EstDéfait)
{
   if (tourHéros)
   {
      armée.Attaquer(horde);
   }
   else
   {
      horde.Attaquer(armée);
   }
   Console.WriteLine(new string('-', 70));
   tourHéros = !tourHéros;
}
if (horde.EstDéfait)
{
   Console.Write("Victoire de l'armée. Encore vivants : ");
   armée.PrésenterVivants();
}
else
{
   Console.Write("Victoire de la horde. Encore vivants : ");
   horde.PrésenterVivants();
}

Un exemple d'exécution de ce programme serait :

Valentin frappe GRRR
        Avant le coup, GRRR a 50 vie
        Après le coup, GRRR a 40 vie
----------------------------------------------------------------------
HSSSS frappe Bill le petit
        Avant le coup, Bill le petit a 75 vie
        Après le coup, Bill le petit a 64 vie
----------------------------------------------------------------------
Galahad frappe prkkk
        Avant le coup, prkkk a 38 vie
        Après le coup, prkkk a 15 vie
----------------------------------------------------------------------
BRK frappe Brute immonde
        Avant le coup, Brute immonde a 64 vie
        Après le coup, Brute immonde a 50 vie
----------------------------------------------------------------------
Bill le petit frappe prkkk
        Avant le coup, prkkk a 15 vie
        Après le coup, prkkk a 0 vie
----------------------------------------------------------------------
HSSSS frappe Galahad
        Avant le coup, Galahad a 55 vie
        Après le coup, Galahad a 44 vie
----------------------------------------------------------------------
Galahad frappe FFFT
        Avant le coup, FFFT a 15 vie
        Après le coup, FFFT a -10 vie
----------------------------------------------------------------------
HSSSS frappe Bill le petit
        Avant le coup, Bill le petit a 64 vie
        Après le coup, Bill le petit a 52 vie
----------------------------------------------------------------------
Galahad frappe GRRR
        Avant le coup, GRRR a 40 vie
        Après le coup, GRRR a 24 vie
----------------------------------------------------------------------
GRRR frappe Galahad
        Avant le coup, Galahad a 44 vie
        Après le coup, Galahad a 28 vie
----------------------------------------------------------------------
Galahad frappe HSSSS
        Avant le coup, HSSSS a 44 vie
        Après le coup, HSSSS a 27 vie
----------------------------------------------------------------------
HSSSS frappe Galahad
        Avant le coup, Galahad a 28 vie
        Après le coup, Galahad a 13 vie
----------------------------------------------------------------------
Galahad frappe HSSSS
        Avant le coup, HSSSS a 27 vie
        Après le coup, HSSSS a 3 vie
----------------------------------------------------------------------
BRK frappe Bill le petit
        Avant le coup, Bill le petit a 52 vie
        Après le coup, Bill le petit a 40 vie
----------------------------------------------------------------------
Valentin frappe HSSSS
        Avant le coup, HSSSS a 3 vie
        Après le coup, HSSSS a -6 vie
----------------------------------------------------------------------
GRRR frappe Galahad
        Avant le coup, Galahad a 13 vie
        Après le coup, Galahad a -1 vie
----------------------------------------------------------------------
Brute immonde frappe GRRR
        Avant le coup, GRRR a 24 vie
        Après le coup, GRRR a 9 vie
----------------------------------------------------------------------
GRRR frappe Valentin
        Avant le coup, Valentin a 85 vie
        Après le coup, Valentin a 70 vie
----------------------------------------------------------------------
Valentin frappe GRRR
        Avant le coup, GRRR a 9 vie
        Après le coup, GRRR a -3 vie
----------------------------------------------------------------------
BRK frappe Valentin
        Avant le coup, Valentin a 70 vie
        Après le coup, Valentin a 58 vie
----------------------------------------------------------------------
Brute immonde frappe BRK
        Avant le coup, BRK a 40 vie
        Après le coup, BRK a 21 vie
----------------------------------------------------------------------
BRK frappe Valentin
        Avant le coup, Valentin a 58 vie
        Après le coup, Valentin a 47 vie
----------------------------------------------------------------------
Valentin frappe BRK
        Avant le coup, BRK a 21 vie
        Après le coup, BRK a 6 vie
----------------------------------------------------------------------
BRK frappe Valentin
        Avant le coup, Valentin a 47 vie
        Après le coup, Valentin a 32 vie
----------------------------------------------------------------------
Valentin frappe BRK
        Avant le coup, BRK a 6 vie
        Après le coup, BRK a -7 vie
----------------------------------------------------------------------
Victoire de l'armée. Encore vivants : Bill le petit avec 40 vies; Valentin avec 32 vies; Brute immonde avec 50 vies;

N'oubliez pas de remettre le labo 01 (au plus tard à 23 h 59 le 1er mars sinon la boîte de remise sera close!)

4 et 5 mars

 

Jour de mise à niveau (cours suspendus)

6 et 7 mars

 

Jour de mise à niveau (cours suspendus)

11 et 12 mars

S11

Au menu :

  • Examen de mi-session

Vous pourrez quitter ensuite

Note : aucune documentation permise; crayon et efface seulement

13 et 14 mars

S12

 

18 et 19 mars

S13

 

20 et 21 mars

S14

 

25 et 26 mars

S15

 

27 et 28 mars

S16

 

1 avril

s/o

Lundi de Pâques, cours suspendus

2 avril

S17

À réfléchir (je perds une séance de trois périodes avec un des trois groupes le 1 avril; je ne suis pas sûr de la bonne stratégie à prendre avec les deux autres aujourd'hui)

3 et 4 avril

S18

 

8 et 9 avril

S19

 

10 et 11 avril

S20

 

15 et 16 avril

S21

 

17 et 18 avril

S22

 

22 et 23 avril

S23

 

24 et 25 avril

S24

 

29 et 30 avril

S25

 

1 et 2 mai

S26

 

6 et 7 mai

S27

 

8 mai

S28

 

9 mai

s/o

Journée d'examen de français / formation générale (cours suspendus)

13 et 14 mai

S29

 

15 mai

s/o

Épreuve uniforme de langue d'enseignement (cours suspendus)

16 mai

S30

 

20 mai

s/o

Fête des patriotes (jour férié)

21 mai

S31

Cours selon l'horaire du lundi

Petits coups de pouces

Vous trouverez ici quelques documents, la plupart petits, qui peuvent vous donner un petit coup de pouce occasionnel.

Vous trouverez aussi des exemples de code C# dans la section Divers – C# du site, mais notez que je n'ai pas nécessairement harmonisé ces exemples (écrits pour des cours plus avancés, sous forme de survols) aux standards de programmation appliqués dans le présent cours. À lire avec prudence et discrimination, donc.

Travaux pratiques

Si vous cherchez les énoncés des travaux pratiques, vous pourrez entre autres les trouver ci-dessous (note : ce tableau est celui de H2021; je ne l'ai pas mis à jour pour H2024).

Travail Nom Rôle

Labo 00

Le Cryptographe

Travail sur l'encapsulation et la conception de classes

Labo 01

À venir

Travail sur l'héritage et le polymorphisme

Labo 02

À venir

Travail sur les interfaces, l'encapsulation et le code générique

Labo 03

À venir

Travail sur les dictionnaires, les fonctions génériques et les entrées / sorties

PFI

Production finale d'intégration

À venir

Solutionnaires et exemples

Quelques solutionnaires suivent. En espérant que ça vous aide à organiser vos idées!

Programme de test – S04 Exercice 1a

L'exercice 1a de la séance S05 porte sur une classe Point générale dont chaque instance représente un point dans n'importe quel quadrant du plan cartésien. Un programme de test pour cet exercice suit.

//---------------------------------------------------------
// Programme de test de la classe Point
// 
// Ce programme vérifie que la classe Point fait 
// correctement son travail
//
// par Pierre Prud'homme, 2013 (retouché par Patrice Roy, 2020 puis 2023)
//---------------------------------------------------------
using System;

// test du constructeur par défaut
Point pDéfaut = new ();
AfficherPoint("Test du constructeur par défaut", pDéfaut);
AfficherSéparateur();

// test du constructeur paramétrique
Point pQuadrant1 = new (1.1f, 1.1f);
Point pQuadrant2 = new (-2.2f, 2.2f);
Point pQuadrant3 = new (-3.3f, -3.3f);
Point pQuadrant4 = new (4.4f, -4.4f);

AfficherPoint("Test du constructeur paramétrique pour Q1", pQuadrant1);
AfficherSéparateur();
AfficherPoint("Test du constructeur paramétrique pour Q2", pQuadrant2);
AfficherSéparateur();
AfficherPoint("Test du constructeur paramétrique pour Q3", pQuadrant3);
AfficherSéparateur();
AfficherPoint("Test du constructeur paramétrique pour Q4", pQuadrant4);
AfficherSéparateur();

// test du mutateur de x et de y
pQuadrant1.X = 10.10f;
pQuadrant1.Y = 10.10f;
AfficherPoint("Test du mutateur de Q1", pQuadrant1);
AfficherSéparateur();

TesterDistance();


// --------------------------
// fin du programme principal
// --------------------------


static bool AssezProches(float f0, float f1) => Math.Abs(f0 - f1) <= Math.Pow(10, -6);
static void TesterDistanceEx(Point p0, Point p1, float attendu)
{
   float dist = p0.Distance(p1);
   if (AssezProches(dist, attendu))
   {
      Console.WriteLine($"Distance entre [{p0.X},{p0.Y}] et [{p1.X},{p1.Y}] environ {attendu} comme prévu");
   }
   else
   {
      Console.WriteLine($"ERREUR : distance entre [{p0.X},{p0.Y}] et [{p1.X},{p1.Y}] == {dist}, mais {attendu} est attendu");
   }
}
static void TesterDistance()
{
   TesterDistanceEx(new Point(0,0), new Point(0,0), 0);
   TesterDistanceEx(new Point(0,0), new Point(1,0), 1);
   TesterDistanceEx(new Point(0,0), new Point(0,1), 1);
   TesterDistanceEx(new Point(0,0), new Point(1,1), (float) Math.Sqrt(2));
}

static void AfficherPoint(string message, Point p)
{
   Console.WriteLine($"{message} : le point vaut [{p.X}, {p.Y}]");
}
static string CréerSéparateur(int nbCar) => new string('-', nbCar);
static void AfficherSéparateur()
{
   const int NB_CAR_LIGNE = 72;
   Console.WriteLine($"\n{CréerSéparateur(NB_CAR_LIGNE)}\n");
}

Programme de test – S04 Exercice 1b

L'exercice 1b de la séance S04 porte sur une classe PointQuadrant1 générale dont chaque instance représente un point situé dans le premier quadrant du plan cartésien. Un programme de test pour cet exercice suit.

//---------------------------------------------------------
// Programme de test de la classe PointQuadrant1
// 
// Ce programme vérifie que la classe Point fait 
// correctement son travail
//
// par Pierre Prud'homme, 2013 (retouché par Patrice Roy, 2020 puis 2023)
//---------------------------------------------------------
using System;

TesterConstructeurParamétrique();
TesterMutateurs();


// --------------------------
// fin du programme principal
// --------------------------


static void AfficherPoint(string message, PointQuadrant1 p)
{
   Console.WriteLine($"{message} :");
   Console.WriteLine($"Le point vaut [{p.X}, {p.Y}]");
}
static string CréerSéparateur(int nbCar) => new string('-', nbCar);
static void AfficherSéparateur()
{
   const int NB_CAR_LIGNE = 72;
   Console.WriteLine($"\n{CréerSéparateur(NB_CAR_LIGNE)}\n");
}

static void TesterConstructeurParamétrique()
{
   // tests du constructeur paramétrique
   TesterPoint(1.1f, 1.1f);
   TesterPoint(-2.2f, 2.2f);
   TesterPoint(-3.3f, -3.3f);         
   TesterPoint(4.4f, -4.4f);
}

static void TesterPoint(float x, float y)
{
   Console.WriteLine($"Point reçu : [{x}, {y}]");
   try
   {
      PointQuadrant1 p = new (x, y);
      AfficherPoint("Test réussi du constructeur paramétrique pour PointQuadrant1", p);
   }
   catch (CoordonnéeXInvalideException)
   {
      Console.WriteLine("Point invalide en x lors de la construction");
   }
   catch (CoordonnéeYInvalideException)
   {
      Console.WriteLine("Point invalide en y lors de la construction");
   }
   AfficherSéparateur();
}

static void TesterMutateurs()
{
   PointQuadrant1 p = new (0, 0);

   ModifierPoint(p, 11.0f, p.Y);
   ModifierPoint(p, p.X, 11.0f);
   ModifierPoint(p, 111.0f, 111.0f);
   ModifierPoint(p, -22.2f, p.Y);
   ModifierPoint(p, p.X, -22.2f);
   ModifierPoint(p, -222.0f, -222.0f);
}

static void ModifierPoint(PointQuadrant1 p, float x, float y)
{
   Console.WriteLine($"Modification du point : [{x}, {y}]");
   try
   {
      p.X = x;
      p.Y = y;
      Console.WriteLine("Test réussi de la mutation du point");
   }
   catch (CoordonnéeXInvalideException)
   {
      Console.WriteLine("Point invalide en x lors de la modification");
   }
   catch (CoordonnéeYInvalideException)
   {
      Console.WriteLine("Point invalide en y lors de la modification");
   }
   AfficherPoint("Après mutation ", p);
   AfficherSéparateur();
}

Code vu en classe à la séance S05 pour l'exercice 3 de la séance S04

Le code vu en classe suit.

Classe Algos

Notez que cette classe est en évolution alors que la session progresse, et que nous la séparerons éventuellement en plusieurs classes.

using System;
namespace z
{
   class Algos
   {
      public static bool EstEntreInclusif(int val, int min, int max) =>
         min <= val && val <= max;
      static char[] voyelles = { 'a', 'e', 'i', 'o', 'u', 'y' };
      //
      // Ceci est un cas raisonnable de double point de sortie pour une fonction :
      // sortir dès qu'on a trouvé la réponse permet d'économiser du temps, peut-être
      // même _beaucoup_ de temps
      //
      public static bool EstDans(char c, char [] cars)
      {
         foreach(char ch in cars)
            if(ch == c)
               return true;
         return false;
      }
      public static bool ContientSeulementConsonnnes(string s)
      {
         foreach(char c in s)
            if(!EstConsonne(c))
               return false;
         return true;
      }
      public static bool EstVoyelle(char c) => EstDans(char.ToLower(c), voyelles);
      public static bool EstConsonne(char c) => char.IsAsciiLetter(c) && !EstVoyelle(c);
   }
}

Classe Personnage

using System;
namespace z
{
   class ForceInvalideException : Exception { }
   class NomInvalideException : Exception { }
   class Personnage
   {
      public int Vie { get; private set; }
      public bool EstMort => Vie <= 0;
      public bool EstVivant => !EstMort;
      public string Nom { get; private init; }
      public int Force { get; private init; }
      public Personnage(string nom, int vie, int force)
      {
         Nom = nom;
         Vie = vie;
         Force = force;
      }
   }
}

Classe Héros

using System;
namespace z
{
   class Héros : Personnage
   {
      public Héros(string nom, int force)
         : base(nom, GénérerVieInitiale(), ValiderForce(force))
      {
      }
      static int GénérerVieInitiale()
      {
         const int VIE_MIN = 50,
                   VIE_MAX = 100;
         return new Random().Next(VIE_MIN, VIE_MAX + 1); // bof
      }
      const int FORCE_MIN = 10,
                FORCE_MAX = 20;
      static bool EstForceValide(int candidate) =>
         Algos.EstEntreInclusif(candidate, FORCE_MIN, FORCE_MAX);
      static int ValiderForce(int candidate) =>
         EstForceValide(candidate) ? candidate : throw new ForceInvalideException();
   }
}

Classe Monstre

using System;
namespace z
{
   class Monstre : Personnage
   {
      public Monstre(string nom, int vie, int force)
         : base(ValiderNom(nom), vie, ValiderForce(force))
      {
      }
      const int LG_MAX_NOM = 5;
      static bool EstNomValide(string candidat) =>
         candidat.Length <= LG_MAX_NOM &&
         Algos.ContientSeulementConsonnes(candidat);
      static string ValiderNom(string candidat) =>
         EstNomValide(candidat) ? candidat : throw new NomInvalideException();
      const int FORCE_MIN = 15,
                FORCE_MAX = 25;
      static bool EstForceValide(int candidate) =>
         Algos.EstEntreInclusif(candidate, FORCE_MIN, FORCE_MAX);
      static int ValiderForce(int candidate) =>
         EstForceValide(candidate) ? candidate : throw new ForceInvalideException();
   }
}

Code (complet cette fois) vu en classe à la séance S06 pour l'exercice 3 de la séance S04

Le code vu en classe suit.

Classe Algos

Notez que cette classe est en évolution alors que la session progresse, et que nous la séparerons éventuellement en plusieurs classes. Depuis la version précédente, rien n'a changé.

using System;
namespace z
{
   class Algos
   {
      public static bool EstEntreInclusif(int val, int min, int max) =>
         min <= val && val <= max;
      static char[] voyelles = { 'a', 'e', 'i', 'o', 'u', 'y' };
      //
      // Ceci est un cas raisonnable de double point de sortie pour une fonction :
      // sortir dès qu'on a trouvé la réponse permet d'économiser du temps, peut-être
      // même _beaucoup_ de temps
      //
      public static bool EstDans(char c, char [] cars)
      {
         foreach(char ch in cars)
            if(ch == c)
               return true;
         return false;
      }
      public static bool ContientSeulementConsonnnes(string s)
      {
         foreach(char c in s)
            if(!EstConsonne(c))
               return false;
         return true;
      }
      public static bool EstVoyelle(char c) => EstDans(char.ToLower(c), voyelles);
      public static bool EstConsonne(char c) => char.IsAsciiLetter(c) && !EstVoyelle(c);
   }
}

Classe Personnage

Depuis la version précédente, nous avons ajouté la méthode Frapper (notez la qualification protected). Nous avons choisi d'offrir une fonction générale à deux paramètres qui pourra être appelée par d'autres de manière à préserver le côté privé du mutateur de Vie.

using System;
namespace z
{
   class ForceInvalideException : Exception { }
   class NomInvalideException : Exception { }
   class Personnage
   {
      public int Vie { get; private set; }
      public bool EstMort => Vie <= 0;
      public bool EstVivant => !EstMort;
      public string Nom { get; private init; }
      public int Force { get; private init; }
      public Personnage(string nom, int vie, int force)
      {
         Nom = nom;
         Vie = vie;
         Force = force;
      }
      protected void Frapper(Personnage autre, int dégâts)
      {
         autre.Vie -= dégâts;
      }
   }
}

Classe Héros

Depuis la version précédente, nous avons ajouté la méthode Frapper. Nous avons choisi d'offrir une fonction spécialisée à un paramètre qui déléguera le travail plus général vers la méthode à deux paramètres du parent.

using System;
namespace z
{
   class Héros : Personnage
   {
      public Héros(string nom, int force)
         : base(nom, GénérerVieInitiale(), ValiderForce(force))
      {
      }
      static int GénérerVieInitiale()
      {
         const int VIE_MIN = 50,
                   VIE_MAX = 100;
         return new Random().Next(VIE_MIN, VIE_MAX + 1); // bof
      }
      const int FORCE_MIN = 10,
                FORCE_MAX = 20;
      static bool EstForceValide(int candidate) =>
         Algos.EstEntreInclusif(candidate, FORCE_MIN, FORCE_MAX);
      static int ValiderForce(int candidate) =>
         EstForceValide(candidate) ? candidate : throw new ForceInvalideException();
      public void Frapper(Personnage autre)
      {
         const int PCT_MIN = 50,
                   PCT_MAX = 100;
         int dégâts = Force * new Random().Next(PCT_MIN, PCT_MAX + 1) / 100;
         Frapper(autre, dégâts);
      }
   }
}

Classe Monstre

Depuis la version précédente, nous avons ajouté la méthode Frapper. Nous avons choisi d'offrir une fonction spécialisée à un paramètre qui déléguera le travail plus général vers la méthode à deux paramètres du parent.

using System;
namespace z
{
   class Monstre : Personnage
   {
      public Monstre(string nom, int vie, int force)
         : base(ValiderNom(nom), vie, ValiderForce(force))
      {
      }
      const int LG_MAX_NOM = 5;
      static bool EstNomValide(string candidat) =>
         candidat.Length <= LG_MAX_NOM &&
         Algos.ContientSeulementConsonnes(candidat);
      static string ValiderNom(string candidat) =>
         EstNomValide(candidat) ? candidat : throw new NomInvalideException();
      const int FORCE_MIN = 15,
                FORCE_MAX = 25;
      static bool EstForceValide(int candidate) =>
         Algos.EstEntreInclusif(candidate, FORCE_MIN, FORCE_MAX);
      static int ValiderForce(int candidate) =>
         EstForceValide(candidate) ? candidate : throw new ForceInvalideException();
      public void Frapper(Personnage autre)
      {
         const int PCT_MIN = 50,
                   PCT_MAX = 75;
         int dégâts = Force * new Random().Next(PCT_MIN, PCT_MAX + 1) / 100;
         Frapper(autre, dégâts);
      }
   }
}

Programme de test

Le code de notre programme de test suit.

using System;
Héros héros = new ("Adam", 18);
Monstre monstre = new ("GRR", 75, 20);
Tour àQui = ChoisirProtagoniste();
while(héros.EstVivant && monstre.EstVivant)
{
   Console.WriteLine($"Avant le choc, {héros.Nom} a {héros.Vie} vie");
   Console.WriteLine($"Avant le choc, {monstre.Nom} a {monstre.Vie} vie");
   if(àQui == Tour.héros)
   {
      Console.WriteLine($"{héros.Nom} frappe {monstre.Nom}");
      héros.Frapper(monstre);
      àQui = Tour.monstre;
   }
   else
   {
      Console.WriteLine($"{monstre.Nom} frappe {héros.Nom}");
      monstre.Frapper(héros);
      àQui = Tour.héros;
   }
   Console.WriteLine($"Après le choc, {héros.Nom} a {héros.Vie} vie");
   Console.WriteLine($"Après le choc, {monstre.Nom} a {monstre.Vie} vie");
   Console.WriteLine(new string('-', 60));
}
if (héros.EstMort)
   Console.WriteLine($"{héros.Nom} est mort... snif!");
if (monstre.EstMort)
   Console.WriteLine($"{monstre.Nom} est mort... ouf!");

//////////////////////////

static Tour ChoisirProtagoniste() =>
   new Random().Next() % 2 == 0? Tour.héros : Tour.monstre;
enum Tour { héros, monstre }

Code vu en classe à la séance S06 pour l'exercice 4 de la séance S04

Le code vu en classe suit.

Classe Point

using System;
namespace S04ex04
{
   class Point
   {
      int x;
      int y;
      static bool EstXValide(int x) => x >= 0;
      static bool EstYValide(int y) => y >= 0;
      public int X
      {
         get => x;
         set
         {
            x = EstXValide(value) ? value : throw new ArgumentException(); 
         }
      }
      public int Y
      {
         get => y;
         set
         {
            y = EstYValide(value) ? value : throw new ArgumentException();
         }
      }

      public Point(int x, int y)
      {
         X = x;
         Y = y;
      }
      public Point() : this(0,0)
      {
      }
   }
}

Classe Carré

using System;
namespace S04ex04
{
   class Carré
   {
      public Point Position
      {
         get; private init;
      }
      public int Côté
      {
         get; private init;
      }
      public ConsoleColor Couleur
      {
         get; private init;
      }
      public Carré(Point pos, int côté, ConsoleColor couleur)
      {
         Position = pos;
         Côté = côté;
         Couleur = couleur;
      }
      public void Dessiner()
      {
         ConsoleColor avant = Console.ForegroundColor;
         Console.ForegroundColor = Couleur;
         for (int ligne = 0; ligne != Côté; ++ligne)
         {
            for(int col = 0; col != Côté; ++col)
            {
               Console.SetCursorPosition(Position.X + col, Position.Y + ligne);
               Console.Write('#');
            }
         }
         Console.ForegroundColor = avant;
      }
   }
}

Code de test

using System;

Carré[] carrés = new Carré[]
{
   new Carré(new Point(2, 5), 5, ConsoleColor.Blue),
   new Carré(new Point(15, 8), 3, ConsoleColor.Green),
   new Carré(new Point(7, 12), 6, ConsoleColor.Yellow)
};
Random r = new ();
for(int i = 0; i != 10; ++i)
{
   Console.Clear();
   foreach (Carré c in carrés)
      c.Dessiner();
   System.Threading.Thread.Sleep(1000);
   foreach (Carré c in carrés)
   {
      try
      {
         c.Position.X += r.Next(0, 5) - 2;
         c.Position.Y += r.Next(0, 5) - 2;
      }
      catch(ArgumentException)
      {
      }
   }
}

Code vu en classe lors de la séance S13

Nous avons fait trois petites structures de données dans ce cours, soit :

Classe Tableau

Le code de la classe suit :

using System;
using System.Collections.Generic;
using System.Diagnostics.SymbolStore;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace z
{
   class Tableau
   {
      int[] Éléments { get; set; }
      public int Count { get; private set; }
      public int Capacity { get => Éléments.Length; }
      public bool EstVide { get => Count == 0; }
      public bool EstPlein { get => Count == Capacity; }
      public Tableau()
      {
         Count = 0;
         Éléments = new int[0]; // ou Éléments = null
      }
      public void Add(int valeur)
      {
         if (EstPlein)
            Croître();
         Éléments[Count] = valeur;
         ++Count;
      }
      private void Croître()
      {
         int nouvelleCap = Capacity == 0? 64 : Capacity * 2;
         int[] nouvTab = new int[nouvelleCap];
         for (int i = 0; i != Count; ++i)
            nouvTab[i] = Éléments[i];
         Éléments = nouvTab;
      }
      public int Find(int valeur)
      {
         for (int i = 0; i != Count; ++i)
            if (valeur.Equals(Éléments[i]))
               return i;
         return -1;
      }
      public void RemoveAt(int indice)
      {
         for (; indice < Count - 1; ++indice)
            Éléments[indice] = Éléments[indice + 1];
         --Count;
      }
      public void Remove(int valeur)
      {
         int indice = Find(valeur);
         if(indice != -1)
            RemoveAt(indice);
      }
      public int At(int indice)
      {
         return Éléments[indice];
      }
   }
}

Classe Pile (version reposant sur un Tableau)

Le code de la classe suit (je ne répète pas la classe Tableau par souci d'économie) :

class PileVideException : Exception { }
class Pile
{
   Tableau Substrat { get; init; }
   public Pile()
   {
      Substrat = new();
   }
   public bool EstVide { get => Substrat.EstVide; }
   public void Push(int valeur) // en français : Empiler
   {
      Substrat.Add(valeur);
   }
   public int Peek()
   {
      if (EstVide)
         throw new PileVideException();
      return Substrat.At(Substrat.Count - 1);
   }
   public int Pop()
   {
      int valeur = Peek();
      Substrat.RemoveAt(Substrat.Count - 1);
      return valeur;
   }
}

Classe Pile (version reposant sur des noeuds)

Le code de la classe suit :

class PileVideException : Exception { }
class Pile
{
   class Noeud
   {
      public int Valeur { get; init; }
      public Noeud Prédécesseur { get; set; }
      public Noeud(int valeur)
      {
         Valeur = valeur;
         Prédécesseur = null;
      }
   }
   Noeud Tête { get; set; }
   public Pile()
   {
      Tête = null;
   }
   public bool EstVide { get => Tête == null; }
   public void Push(int valeur) // en français : Empiler
   {
      Noeud p = new(valeur);
      p.Prédécesseur = Tête;
      Tête = p;
   }
   public int Peek()
   {
      if (EstVide)
         throw new PileVideException();
      return Tête.Valeur;
   }
   public int Pop()
   {
      int valeur = Peek();
      Tête = Tête.Prédécesseur;
      return valeur;
   }
}

Valid XHTML 1.0 Transitional

CSS Valide !