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

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

24 janvier

S00

Au menu :

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

• 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
  • 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, protected, 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 presque tous les 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 $f$ sur une entité $obj$, ce qui rejoint l'approche procédurale que nous avons mis en application dans le cours 420-201-RE, et obj.F(), qui sollicite la méthode $f$ de l'objet $obj$ 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
  • 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é 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();
// ...

    A
   AAA
  AAAAA
 AAAAAAA
AAAAAAAAA

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

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

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

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

classe et instance
   Point est une classe
   pt est une instance de la classe Point
   
pt.x est un attribut d'instance du Point nommé pt
   variable membre de pt
   
pt.X est une propriété d'instance du Point nommé pt
   le get est ce qui permet d'en lire la valeur
   le set est ce qui permet d'en modifier la valeur
   
   (une propriété, typiquement, encadre l'accès à un attribut)
   
Point() est un constructeur par défaut

Point(int x, int y) est un constructeur paramétrique

public : tout le monde y a accès
private : seul un Point y a accès

static : membre de classe

(non-static : membre d'instance)

Encapsulation :

* principe selon lequel un objet se porte garant de son
  intégrité, du début à la fin de sa vie
* principe selon lequel un objet garantit le respect de
  ses invariants

Invariant : ce qui s'avère pour un objet entre deux
appels de ses méthodes

classe
  Point

instance
  pt0, pt1
  
attributs d'instance
  pt.x, pt.y
  variables membres d'une instance
  
propriétés d'instance
   pt.X, pt.Y
   get pour lire
   set pour modifier / écrire
   
constructeur
  par défaut, p.ex. Point.Point()
  paramétrique, p.ex. Point.Point(int x, int y)
  
private si possible
public si nécessaire  

encapsulation :

* principe selon lequel un objet garantit son intégrité
  du début à la fin de sa vie
  
* principe selon lequel un objet se porte garant du
  respect de ses invariants

invariant : état qui s'avère en tout temps entre deux
appels de méthodes

précondition : ce à quoi l'appelant d'une fonction s'engage

postcondition : ce à quoi la fonction appelée s'engage

static : membre de classe

(non-static) : membre d'instance

26 janvier

S01

Au menu :

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

31 janvier

S02

Au menu :

• Simplification de la syntaxe lors d'un appel à new
• Mutateur à la construction seulement : propriétés avec le mot clé init
• Introduction à l'idée d'objet immuable, particulièrement importante dans un langage comme C# où on accède indirectement aux objets
• Présentation du labo 00 – Le cryptographe
• Travail sur le labo 00 – Le cryptographe

// ...
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échiffer? ");
   int cléDéchiffrement = int.Parse(Console.ReadLine());
   Console.WriteLine($"Message \"déchiffré\" : {crypteur.Déchiffrer(cléDéchiffrement)}");
}
while (Poursuivre());
// ...

// ...
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);
// ...

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

2 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

S'il reste du temps :

• Travail sur le labo 00 – Le cryptographe

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 { }

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

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] = '#';
   }
}
s = new string(tab);
Console.WriteLine(s);
s = tab.ToString();
Console.WriteLine(s);

7 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. : chiffre 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 2023
/// 
/// 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 : ");
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!

14 février

S06

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)

16 février

S07

Au menu :

• Finir l'exercice 3 de S04
  • Le problème de la méthode Frapper
• 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

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

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

21 février

S08

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 S07
• 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

23 février

S09

7 mars

S10

Au menu :

• Classes statiques
  • Petit allègement syntaxique sympathique
• Tableaux dynamiques : le type List<T>

Petit exemple simple avec une List<int> :

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.

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

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

9 mars

S11

Au menu :

• Présentation du labo 02
  • Ce laboratoire sera différent des précédents, au sens où il vous laissera plus de latitude que ses prédécesseurs dans la conception des classes
  • Si vous estimez que certaines des consignes auraient gagné à être exprimées différemment, notez vos raisons et nous en discuterons
    • Pour être clair : c'est un chic labo, mais j'aurais fait certaines choses autrement
    • Cela dit, considérant ce que nous savons jusqu'ici, les consignes sont tout à fait convenables, donc faites ce qui est demandé
    • En retour, j'aimerais savoir ce que vous voyez comme perfectibles dans ce travail, et je l'utiliserai moi-même comme rampe de lancement pour plusieurs idées intéressantes suivant sa remise (nous discuterons entre autres de schémas de conception)
  • Une fois que vous aurez livré votre propre version, nous aurons une discussion sur divers enjeux associés à ce travail...
• Travail sur le labo 02

14 mars

S12

Au menu :

• Quelques très petits éléments de notation UML :
  • Boîte décrivant une classe ou une de ses instances
  • Symbole + pour un membre public
  • Symbole - pour un membre privé
  • Nom de la classe
  • Noms des attributs
  • Signatures des méthodes
  • Soulignement pour les membres de classe
• Visualiser la classe Histogramme du labo 02 sous forme UML
• Visualiser les classes Coordonnée et Trajet du labo 02 sous forme UML
• Décrivez en termes de relations OO...
  • Le lien entre un Histogramme et ce qui l'affiche
  • Le lien entre une maman fourmi et des bébés fourmis
  • Le lien entre des profs de diverses disciplines
  • Le lien entre des profs et des parents
  • Le lien entre des profs et des étudiant(e)s
  • Le lien entre le Collège Lionel-Groulx et ses étudiant(e)s
  • Le lien entre un Rectangle et une Forme
  • Le lien entre un Carré et une Forme
  • Le lien entre un Rectangle et un Carré
• Travail sur le labo 02

16 mars

S13

Au menu :

• Revisitons (légèrement) l'exercice 03 de la séance S04 en nous demandant quoi faire si des entités qui ne sont pas des instances de Personnage doivent pouvoir attaquer des instances de Personnage
  • Code que nous avions jusqu'ici
  • Introduction du mot clé interface
• Travail sur le labo 02

21 mars

S14

Au menu :

• Approcher un problème comme celui de créer et initialiser une matrice 2D comme celle du labo 02
  • Variations sur le couplage et la capacité de généraliser
• Introduction à la conception de structures de données
  • Concevoir un tableau dynamique de int (sorte de List<int> simplifiée)
  • Si le temps le permet, concevoir une pile de int à l'aide de ce tableau dynamique
• Les exemples ont été mis à votre disposition :
  • Lien général
  • Classe Tableau
  • Classe Pile avec Tableau comme substrat
  • Classe Pile avec noeuds comme substrat
• S'il reste du temps, travail sur le labo 02

23 mars

S15

Au menu :

• Travail sur le labo 02

Si vous le souhaitez, un exercice :

• Un Immeuble est une structure rectangulaire faite d'au moins un Étage
• Un Étage est une structure rectangulaire faite d'au moins deux Appartement
• Un Appartement est identifié par son numéro d'étage (numéro basé 0, où 0 est le sous-sol) et sa position (basée 1, pas basée 0) dans l'étage. Ainsi, l'appartement 23 est le 3^e appartement de l'étage 2
• Un Appartement contient de 0 à 7 individus
• Votre travail est de déterminer comment évacuer un Immeuble lors d'un incendie. Voici comment le calcul doit se faire :
  • Un individu à la fois peut sortir d'un Appartement
  • Sur chaque Étage, il y a un escalier aux deux extrémités du corridor situé entre les Appartement
  • Il peut y avoir un invididu maximum devant chaque Appartement. Pour simplifier le modèle, supposez que les portes des appartements ne soient pas en face l'une de l'autre, p.ex. :

+---+---+---+---+
| 1     | 3     |
+-\ ----+-\ ----+
#  x  x    x  x #
+----\ -+----\ -+
|     2 |     4 |
+---+---+---+---+

• Selon ce schéma :
  • Il y a quatre Appartement, donc un espace (noté 'x') devant chaque Appartement et
  • Deux escaliers (notés '#')
  • Si un individu est devant l'appartement 3, alors il peut faire deux pas vers la gauche pour atteindre l'escalier de gauche ou un pas à droite pour atteindre l'escalier de droite
• Pour sortir d'un Immeuble, un individu doit atteindre l'étage 1 (pas l'étage 0) et atteindre un escalier.
• Un individu fait au maximum un pas par tour. Sortir d'un Appartement compte pour un pas. Monter ou descendre d'un étage par un escalier compte pour un pas. Pour prendre un escalier, il faut au préalable avoir atteint la case adjacente dans un corridor (p. ex. : pour un Étage de cinq appartements, il faut d'abord être soit à la case 0, soit à la case 4 de l'étage pour pouvoir prendre un escalier)
• Sur un Étage donné, il ne peut y avoir qu'un individu au maximum dans chaque escalier
• Votre programme doit  :
  • Modéliser cette situation, et
  • Montrer, tour par tour, l'état de la situation, jusqu'à ce que l'immeuble ait été complètement évacué.

28 mars

S16

30 mars

S17

Au menu :

• Concevoir une file d'entiers, à partir d'un substrat que nous avons défini collectivement
  • Ce substrat était une liste doublement chaînée d'entiers

namespace z
{
   class ListeVideException : Exception { }
   class Liste
   {
      class Noeud
      {
         public int Valeur { get; private init; }
         public Noeud Pred { get; set; } = null;
         public Noeud Succ { get; set; } = null;
         public Noeud(int val)
         {
            Valeur = val;
         }
      }
      Noeud Tête { get; set; } = null;
      Noeud Queue { get; set; } = null;
      public Liste()
      {
      }
      public bool EstVide => Tête == null;
      public int Count { get; private set; } = 0;
      public void AjouterDébut(int valeur)
      {
         Noeud p = new(valeur);
         if(EstVide)
         {
            Tête = Queue = p;
         }
         else
         {
            p.Succ = Tête;
            Tête.Pred = p;
            Tête = p;
         }
         ++Count;
      }
      public void AjouterFin(int valeur)
      {
         Noeud p = new(valeur);
         if(EstVide)
         {
            Tête = Queue = p;
         }
         else
         {
            Queue.Succ = p;
            p.Pred = Queue;
            Queue = p;
         }
         ++Count;
      }
      public int ConsulterDébut() =>
         EstVide ? throw new ListeVideException() : Tête.Valeur;
      public int ConsulterFin() =>
         EstVide ? throw new ListeVideException() : Queue.Valeur;

      public void RetirerDébut()
      {
         if (EstVide)
            throw new ListeVideException();
         Tête = Tête.Succ;
         if (Tête == null)
         {
            Queue = null;
         }
         else
         {
            Tête.Pred = null;
         }
         --Count;
      }
      public void RetirerFin()
      {
         if (EstVide)
            throw new ListeVideException();
         Queue = Queue.Pred;
         if (Queue == null)
         {
            Tête = null;
         }
         else
         {
            Queue.Succ = null;
         }
         --Count;
      }

      public bool Contient(int valeur) => Trouver(valeur) != null;
      //{
      //   for(Noeud p = Tête; p != null; p = p.Succ)
      //      if(p.Valeur == valeur)
      //         return true;
      //   return false;
      //}
      public int Compter(int valeur)
      {
         int n = 0;
         for (Noeud p = Tête; p != null; p = p.Succ)
            if (p.Valeur == valeur)
               ++n;
         return n;
      }
      // trouver le premier noeud contenant la valeur 'valeur'
      private Noeud Trouver(int valeur)
      {
         for (Noeud p = Tête; p != null; p = p.Succ)
            if (p.Valeur == valeur)
               return p;
         return null;
      }
      // supprime la première occurrence de valeur dans la liste,
      // retourne true seulement s'il y a eu suppression
      public bool Supprimer(int valeur)
      {
         Noeud p = Trouver(valeur);
         if(p == null) return false;
         if (p == Tête)
            RetirerDébut();
         else if (p == Queue)
            RetirerFin();
         else
         {
            p.Pred.Succ = p.Succ;
            p.Succ.Pred = p.Pred;
            --Count;
         }
         return true;
      }

      // TEMPORAIRE (PATCH)
      public void Afficher()
      {
         for(Noeud p = Tête; p != null; p = p.Succ)
            Console.Write($"{p.Valeur} ");
      }
   }
}

namespace z
{
   class File
   {
      Liste Substrat { get; init; } = new();
      public bool EstVide => Substrat.EstVide;
      public void Enfiler(int valeur)
      {
         Substrat.AjouterDébut(valeur);
      }
      public int Peek() => Substrat.ConsulterFin();
      public int Défiler()
      {
         int valeur = Peek();
         Substrat.RetirerFin();
         return valeur;
      }
   }
}

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

namespace z
{
   internal class Tableau<T> where T : IEquatable<T>
   {
      T[] É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 T[0]; // ou Éléments = null
      }
      public void Add(T valeur)
      {
         if (EstPlein)
            Croître();
         Éléments[Count] = valeur;
         ++Count;
      }
      private void Croître()
      {
         int nouvelleCap = Capacity == 0? 64 : Capacity * 2;
         T[] nouvTab = new T[nouvelleCap];
         for (int i = 0; i != Count; ++i)
            nouvTab[i] = Éléments[i];
         Éléments = nouvTab;
      }
      public int Find(T 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(T valeur)
      {
         int indice = Find(valeur);
         if(indice != -1)
            RemoveAt(indice);
      }
      public T At(int indice) =>
         léments[indice];
   }
}

4 avril

S18

Au menu :

• Votre chic prof doit s'absenter pour raisons personnelles, mais a déposé un chic labo 03 sur Colnet pour votre plus grand bonheur!

11 avril

S19

Au menu :

• Retour sur l'examen de mi-session
• Introduction aux algorithmes génériques
  • Trouver
  • Compter
• Paramétrer nos algorithmes génériques à l'aide de fonctions d'ordre supérieur
  • TrouverSi
  • CompterSi
• Quelques exercices

Exercice 0

Écrivez une classe FilePrioritaire<T> ayant les caractéristiques suivantes :

• Elle utilisera un List<T> (le type List de C#) comme substrat
• Une FilePrioritaire<T> nouvellement construite sera vide
• Elle exposera une propriété EstVide qui vaudra true seulement si elle est vide
• Elle inclura un critère de tri déterminé à la construction
  • Note : un critère de tri sera une fonction de comparaison trilatérale, prenant en paramètre deux T retournant un int
• Elle exposera une méthode Add acceptant en paramètre un T et l'ajoutant au substrat
• Elle exposera une méthode Prochain retournant le premier T dans le substrat et l'en extrayant
• Invariant : les éléments d'une FilePrioritaire<T> seront triés en fonction de son critère de tri
  • Note : utilisez la fonction Trier dans l'exemple ci-dessous pour réaliser ce tri

Code de test possible :

using System;
using System.Collections.Generic;

FilePrioritaire<int> file = new (TriDécroissant);
foreach(int n in new []{ 2, 3, 5, 7, 11 })
   file.Add(n);

while(!file.EstVide)
   Console.WriteLine(file.Prochain()); // 11 7 5 3 2

// ...
static void Trier<T>(List<T> lst, Func<T,T,int> critère) // tri à bulles, pour fins de simplicité
{
   for(int i = 0; i < lst.Count - 1; ++i)
      for(int j = i + 1; j < lst.Count; ++j)
         if(critère(lst[i], lst[j]) > 0)
            PermuterÉléments(lst, i, j);
}
static void PermuterÉléments<T>(List<T> lst, int i, int j)
{
   T elem = lst[i];
   lst[i] = lst[j];
   lst[j] = elem;
}
// ...
static int TriDécroissant(int x, int y) => y - x;
// ...

Affichage attendu :

11
7
5
3
2

Pour le plaisir : pouvez-vous faire une FilePrioritaire<Client> pour une classe Client où chaque client a un nom, un prénom et une dette, et où les clients les plus endettés sont prioritaires sur les moins endettés? Si deux clients sont aussi endettés l'un que l'autre, alors la priorité doit respecter l'ordre lexicographique (ordre croissant de nom, puis de prénom si deux noms sont équivalents).

class FilePrioritaire<T>
{
   Func<T,T,int> Critère;
   List<T> Elems{ get;init; } = new();
   public FilePrioritaire(Func<T,T,int> critère)
   {
      Critère = critère;
   }
   public void Add(T elem)
   {
      Elems.Add(elem);
      Trier(Elems, Critère);
   }
   public T Prochain()
   {
      T elem = Elems[0];
      Elems.RemoveAt(0);
      return elem;
   }
   public bool EstVide => Elems.Count == 0;
}

Exercice 01

Sachant que nous avons implémenté les algorithmes TrouverSi et CompterSi. Ajoutons quelques algorithmes génériques à notre banque d'outils :

EX01.0 – Écrivez l'algorithme Permuter<T>(ref T a, ref T b) qui permutera les valeurs de a et de b, de telle sorte que l'exécution du programme suivant :

int i0 = 2, i1 = 3;
Console.WriteLine($"Avant permutation : {i0}, {i1}");
Permuter(ref i0, ref i1);
Console.WriteLine($"Après permutation : {i0}, {i1}");
double d0 = 2.5, d1 = 3.5;
Console.WriteLine($"Avant permutation : {d0}, {d1}");
Permuter(ref d0, ref d1);
Console.WriteLine($"Après permutation : {d0}, {d1}");
string s0 = "allo", s1 = "toi";
Console.WriteLine($"Avant permutation : \"{s0}\", \"{s1}\"");
Permuter(ref s0, ref s1);
Console.WriteLine($"Après permutation : \"{s0}\", \"{s1}\"");

... affiche ce qui suit :

Avant permutation : 2,3
Après permutation : 3,2
Avant permutation : 2.5,3.5
Après permutation : 3.5,2.5
Avant permutation : "allo","toi"
Après permutation : "toi","allo"

EX01.1 – Écrivez l'algorithme RotaterGauche<T>(List<T> src) qui retourne une List<T> contenant un équivalent des éléments de la List<T> reçue en paramètre, mais où les éléments de src ont été décalés à gauche d'une position de manière cyclique (l'élément à la position 0 dans src est placée à la position Count-1 dans la List<T> résultante), de telle sorte que le programme suivant :

using System;
using System.Collections.Generic;
Afficher(RotaterGauche(new List<int>()));
Afficher(RotaterGauche(new List<int>(){ 2,3,5,7,11 }));

static void Afficher<T>(List<T> lst)
{
   foreach(T obj in lst)
      Console.Write($"{obj} ");
   Console.WriteLine();
}

... affiche ce qui suit (notez la première ligne qui est vide, car nous avons opéré sur... une séquence vide!) :

3 5 7 11 2 

Note : essayez d'implémenter cet algorithme sans allouer de mémoire (sans utiliser new).

EX01.2 – Écrivez l'algorithme RotaterDroite<T>(List<T> src) qui retourne une List<T> contenant un équivalent des éléments de la List<T> reçue en paramètre, mais où les éléments de src ont été décalés à droite d'une position de manière cyclique (l'élément à la position Count-1 dans src est placée à la position 0 dans la List<T> résultante), de telle sorte que le programme suivant :

using System;
using System.Collections.Generic;
Afficher(RotaterDroite(new List<int>()));
Afficher(RotaterDroite(new List<int>(){ 2,3,5,7,11 }));

static void Afficher<T>(List<T> lst)
{
   foreach(T obj in lst)
      Console.Write($"{obj} ");
   Console.WriteLine();
}

... affiche ce qui suit (notez la première ligne qui est vide, car nous avons opéré sur... une séquence vide!) :

11 2 3 5 7 

Note : essayez d'implémenter cet algorithme sans allouer de mémoire (sans utiliser new).

EX01.3 – Écrivez la fonction Concaténer<T>(List<T> lst0, List<T> lst1) qui retournera une List<T> contenant les mêmes éléments que lst0, dans l'ordre, suivis des éléments de lst1, dans l'ordre.

EX01.4 – Écrivez l'algorithme Transformer<T,U>(List<T> src, Func<T,U> fct) qui retourne une List<U> contenant un équivalent des éléments de la List<T> reçue en paramètre, mais transformés par application de la fonction fct, de telle sorte que le programme suivant :

using System;
using System.Collections.Generic;

List<int> lst0 = new List<int>(){ 2,3,5,7,11 };
List<double> lst1 = Transformer(lst0, CarréNégatif);
foreach(double x in lst1)
   Console.Write($"{x} ");
Console.WriteLine();
foreach(string s in Transformer(new List<string>(){ "j'aime", "mon", "prof" }, Exclamer))
   Console.Write($"{s} ");
Console.WriteLine();

static double CarréNégatif(int x) => -1.0 * x * x; // nom pas terrible, je sais
static string Exclamer(string s) => s.ToUpper() + "!";

... affiche ce qui suit :

-4 -9 -25 -49 -121 
J'AIME! MON! PROF!

EX01.5 – Écrivez l'algorithme Cumuler<T,U>(List<T> src, Func<U,T,U> accum, U init) qui reçoit en paramètre une List<T>, une fonction applicable à un U et à un T et retournant un U, de même qu'une valeur initiale de type U, et retourne l'accumulation, de telle sorte que le programme suivant :

using System;
using System.Collections.Generic;

Console.WriteLine($"1+2+3+4+5 == {Cumuler(new List<int>(){ 1,2,3,4,5 }, Somme, 0)}");
Console.WriteLine($"1*2*3*4*5 == {Cumuler(new List<int>(){ 1,2,3,4,5 }, Produit, 1.0)}");
Console.WriteLine($"min(2,-3,5,-7,11) == {Cumuler(new List<int>(){ 2,-3,5,-7,9 }, Minimum, int.MaxValue)}");
var mots = new List<string>() { "yo", "man", "genre" };
Console.Write("La somme des longueurs des mots (");
foreach (string s in mots)
   Console.Write($"{s} ");
Console.WriteLine($"\b) est : {Cumuler(mots, CumulLongueur, 0)}");

static int Somme(int x, int y) => x + y;
static double Produit(double x, int y) => x * y;
static int Minimum(int x, int y) => Math.Min(x, y);
static int CumulLongueur(int lg, string s) => lg + s.Length;

... affiche ce qui suit :

1+2+3+4+5 == 15
1*2*3*4*5 == 120
min(2,-3,5,-7,11) == -7
La somme des longueurs des mots (yo man genre) est : 10

EX01.6 – Écrivez la fonction FiltrerSi<T>(List<T> src, Func<T,bool> pred) qui retournera une List<T> contenant les mêmes éléments que src, dans le même ordre, à ceci près que tous les éléments respectant le prédicat pred auront été supprimés.

EX01.7 – Écrivez la fonction RemplacerSi<T>(List<T> src, Func<T,bool> pred, T post) qui retournera une List<T> contenant les mêmes éléments que src, dans l'ordre, mais dont chaque élément satisfaisant le prédicat pred aura été remplacé par post.

13 avril

S20

Au menu :

• Retour sur le labo 02
  • Rôle d'une classe
  • Rôle d'une fonction
  • Rôle d'un attribut
  • Principe de localité
  • Dangers d'une encapsulation négligente
• Revisiter le labo 02
  • Introduction aux schémas de conception
• Travail sur le labo 03

18 avril

S21

Au menu :

• Résoudre les exercices de la séance S19
• Revisiter les exercices de la séance S19 à l'aide d'expressions λ

static void Permuter<T>(ref T a, ref T b)
{
   T temp = a;
   a = b;
   b = temp;
}

static List<T> RotaterGauche(List<T> src)
{
   List<T> dest = new();
   if(src.Count != 0)
   {
      for(int i = 1; i < src.Count; ++i)
         dest.Add(src[i]);
      dest.Add(src[0]);
   }
   return dest;
}

static void PermuterÉléments<T>(List<T> lst, int i, int j)
{
   T elem = lst[i];
   lst[i] = lst[j];
   lst[j] = temp;
}
static List<T> RotaterGauche(List<T> src)
{
   for(int i = 1; i < src.Count; ++i)
      PermuterÉléments(src, i, i-1);
   return src;
}

static List<T> Concaténer<T>(List<T> lst0, List<T> lst1)
{
   List<T> dest = new();
   foreach(T elem in lst0)
      dest.Add(elem);
   foreach(T elem in lst1)
      dest.Add(elem);
   return dest;
}

static List<T> Concaténer<T>(List<T> lst0, List<T> lst1)
{
   List<T> dest = new(lst0);
   dest.AddRange(lst1);
   return dest;
}

static List<T> Concaténer<T>(params List<T> [] lsts)
{
   List<T> dest = new();
   foreach(var lst in lstsl) dest.AddRange(lst);
   return dest;
}

static List<U> Transformer<T,U>(List<T> src, Func<T,U> fct)
{
   List<U> dest = new();
   foreach(T elem in src)
      dest.Add(fct(elem));
   return dest;
}

static U Cumuler<T,U>(List<T> src, Func<U,T,U> accum, U init)
{
   foreach(T elem in src)
      init = accum(init, elem);
   return init;
}

static List<T> FiltrerSi<T>(List<T> src, Func<T,bool> pred)
{
   List<T> dest = new();
   foreach(T elem in src)
      if(!pred(elem))
         dest.Add(elem);
   return dest;
}

static List<T> RemplacerSi<T>(List<T> src, Func<T,bool> pred, T post)
{
   List<T> dest = new();
   foreach(T elem in src)
      if(pred(elem))
         dest.Add(post);
      else
         dest.Add(elem);
   return dest;
}

static List<T> RemplacerSi<T>(List<T> src, Func<T,bool> pred, T post)
{
   List<T> dest = new();
   foreach(T elem in src)
      dest.Add(pred(elem) ? post : elem);
   return dest;
}

static List<T> RemplacerSi<T>(List<T> src, Func<T,bool> pred, T post) =>
   Transformer(src, elem => pred(elem)? post : elem);

• Quelques interfaces standards
  • IEquatable<T>
  • IComparable<T>
• Profiter de l'héritage d'interfaces pour exprimer des algorithmes génériques
  • Écrire Trouver
  • Écrire Filtrer
  • Écrire Remplacer
  • Écrire Conserver

static int Trouver<T>(List<T> lst, T val) where T : IEquatable<T>
{
   for (int i = 0; i != lst.Count; ++i)
      if (val.Equals(lst[i]))
         return i;
   return -1;
}

• Travail sur le laboratoire 03

20 avril

S22

25 avril

S23

Au menu :

• Remise du laboratoire 03
• Quelques interfaces standards (suite)
  • IEnumerable<T>
  • IEnumerator<T>
• Généraliser les algorithmes génériques
  • Ce qui fait fonctionner foreach
• Revisiter notre Liste<T> de S17
  • Que faire pour qu'une collection soit IEnumerable<T> et pour que foreach puisse s'appliquer sur elle?
    • Détail technique : le mot clé default
    • Implémentation sur notre Tableau<T> de S17
    • Conséquences de cet ajustement
• Présentation du laboratoire 04
• Travail sur le laboratoire 04

Le code fait aujourd'hui suit. Pour la classe Liste<T> :

using System;
using System.Collections;
using System.Collections.Generic;

namespace z
{
   class ListeVideException : Exception { }
   internal class Liste<T> : IEnumerable<T> where T : IEquatable<T>
   {
      class Noeud
      {
         public T Valeur { get; private init; }
         public Noeud Pred { get; set; } = null;
         public Noeud Succ { get; set; } = null;
         public Noeud(T val)
         {
            Valeur = val;
         }
      }
      Noeud Tête { get; set; } = null;
      Noeud Queue { get; set; } = null;
      public Liste()
      {
      }
      public bool EstVide => Tête == null;
      public int Count { get; private set; } = 0;
      public void AjouterDébut(T valeur)
      {
         Noeud p = new(valeur);
         if(EstVide)
         {
            Tête = Queue = p;
         }
         else
         {
            p.Succ = Tête;
            Tête.Pred = p;
            Tête = p;
         }
         ++Count;
      }
      public void AjouterFin(T valeur)
      {
         Noeud p = new(valeur);
         if(EstVide)
         {
            Tête = Queue = p;
         }
         else
         {
            Queue.Succ = p;
            p.Pred = Queue;
            Queue = p;
         }
         ++Count;
      }
      public T ConsulterDébut() =>
         EstVide ? throw new ListeVideException() : Tête.Valeur;
      public T ConsulterFin() =>
         EstVide ? throw new ListeVideException() : Queue.Valeur;

      public void RetirerDébut()
      {
         if (EstVide)
            throw new ListeVideException();
         Tête = Tête.Succ;
         if (Tête == null)
         {
            Queue = null;
         }
         else
         {
            Tête.Pred = null;
         }
         --Count;
      }
      public void RetirerFin()
      {
         if (EstVide)
            throw new ListeVideException();
         Queue = Queue.Pred;
         if (Queue == null)
         {
            Tête = null;
         }
         else
         {
            Queue.Succ = null;
         }
         --Count;
      }

      public bool Contient(T valeur) => Trouver(valeur) != null;
      //{
      //   for(Noeud p = Tête; p != null; p = p.Succ)
      //      if(p.Valeur == valeur)
      //         return true;
      //   return false;
      //}
      public int Compter(T valeur)
      {
         int n = 0;
         for (Noeud p = Tête; p != null; p = p.Succ)
            if (p.Valeur.Equals(valeur))
               ++n;
         return n;
      }
      // trouver le premier noeud contenant la valeur 'valeur'
      private Noeud Trouver(T valeur)
      {
         for (Noeud p = Tête; p != null; p = p.Succ)
            if (p.Equals(valeur))
               return p;
         return null;
      }
      // supprime la première occurrence de valeur dans la liste,
      // retourne true seulement s'il y a eu suppression
      public bool Supprimer(T valeur)
      {
         Noeud p = Trouver(valeur);
         if(p == null) return false;
         if (p == Tête)
            RetirerDébut();
         else if (p == Queue)
            RetirerFin();
         else
         {
            p.Pred.Succ = p.Succ;
            p.Succ.Pred = p.Pred;
            --Count;
         }
         return true;
      }

      // TEMPORAIRE (PATCH)
      public void Afficher()
      {
         for(Noeud p = Tête; p != null; p = p.Succ)
         {
            Console.Write($"{p.Valeur} ");
         }
      }

      class Énumérateur : IEnumerator<T>
      {
         Noeud Cur { get; set; }
         public Énumérateur(Noeud p)
         {
            // se placer juste avant p
            Cur = new Noeud(default);
            Cur.Succ = p;
         }
         public bool MoveNext()
         {
            // essayer d'avancer d'un élément
            // retourner true ssi ça fonctionne
            if (Cur.Succ == null) return false;
            Cur = Cur.Succ;
            return true;
         }

         public void Reset()
         {
         }

         public void Dispose()
         {
         }

         public T Current => Cur.Valeur;

         object IEnumerator.Current => Cur.Valeur;
      }

      public IEnumerator<T> GetEnumerator() =>
         new Énumérateur(Tête);

      IEnumerator IEnumerable.GetEnumerator() =>
         new Énumérateur(Tête);
   }
}

... et pour la classe Tableau<T> :

using System;
using System.Collections;
using System.Collections.Generic;

namespace z
{
   class Tableau<T> : IEnumerable<T> where T : IEquatable<T>
   {
      // indexeur
      public T this[int indice]
      {
         get => Éléments[indice];
         set { Éléments[indice] = value; } // private serait mieux
      }
      T[] É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 T[0]; // ou Éléments = null
      }
      public void Add(T valeur)
      {
         if (EstPlein)
            Croître();
         Éléments[Count] = valeur;
         ++Count;
      }
      // private int[] Croitre(int [] ancien)
      // ...
      // return nouvTab
      // 
      private void Croître()
      {
         int nouvelleCap = Capacity == 0? 64 : Capacity * 2;
         T[] nouvTab = new T[nouvelleCap];
         for (int i = 0; i != Count; ++i)
            nouvTab[i] = Éléments[i];
         Éléments = nouvTab;
      }
      public int Find(T 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(T valeur)
      {
         int indice = Find(valeur);
         if(indice != -1)
            RemoveAt(indice);
      }
      public T At(int indice)
      {
         return Éléments[indice];
      }

      class Énumérateur : IEnumerator<T>
      {
         Tableau<T> Src { get; init; }
         int indice = -1; // initialement avant le début
         public Énumérateur(Tableau <T> src)
         {
            Src = src;
         }
         public bool MoveNext()
         {
            if (indice == Src.Count - 1) return false;
            ++indice;
            return true;
         }

         public void Reset()
         {
         }

         public void Dispose()
         {
         }

         public T Current => Src[indice];

         object IEnumerator.Current => Src[indice];
      }

      public IEnumerator<T> GetEnumerator() =>
         new Énumérateur(this);

      IEnumerator IEnumerable.GetEnumerator() =>
         new Énumérateur(this);
   }
}

27 avril

S24

Au menu :

• Trois trucs mineurs mais utiles :
  • Les uplets
  • Les indexeurs
  • Les méthodes d'extension
• Élargir l'utilité de nos algorithmes génériques en les rendant applicables à tout type énumérable
• Travail sur le laboratoire 04

2 mai

S25

Au menu :

• Introduction à la surcharge d'opérateurs
• Exercices sur la surcharge d'opérateurs
• Mini introduction aux struct, que C# qualifie de « types valeurs » (alors que les class sont des « types références »)
• Travail sur le labo 04

Présentation informelle de la PFI

9 mai

S26

Au menu :

• Fonctionnement d'un programme
  • Fonction Main (silencieuse ou pas) et ses paramètres
  • Lancer un programme qui accepte des paramètres... comme celui de la PFI
• Petite introduction aux entrées / sorties
• Blocs using
• Travail sur la PFI

L'exemple d'entrée-sortie sur des flux textes sans bloc using mais avec bloc finally était :

using System;
using System.IO;

string[] mots =
{
   "J'aime", "mon", "prof"
};
StreamWriter sw = new("MotsFavoris.txt");
try
{
   foreach (string mot in mots)
      sw.WriteLine(GénérerTexte(mot));
}
finally
{
   sw.Close();
}

StreamReader sr = new("MotsFavoris.txt");
try
{
   string plusLongue = "";
   for (string s = sr.ReadLine(); s != null; s = sr.ReadLine())
      if (s.Length > plusLongue.Length)
         plusLongue = s;
   Console.WriteLine($"La ligne la plus longue est {plusLongue}");
}
finally
{
   sr.Close();
}

L'exemple d'entrée-sortie sur des flux textes avec bloc using était :

using System;
using System.IO;

string[] mots =
{
   "J'aime", "mon", "prof"
};

using (StreamWriter sw = new("MotsFavoris.txt"))
{
   foreach (string mot in mots)
      sw.WriteLine(GénérerTexte(mot));
}

using (StreamReader sr = new("MotsFavoris.txt"))
{
   string plusLongue = "";
   for (string s = sr.ReadLine(); s != null; s = sr.ReadLine())
      if (s.Length > plusLongue.Length)
         plusLongue = s;
   Console.WriteLine($"La ligne la plus longue est {plusLongue}");
}

11 mai

S27

Au menu :

• Les sélectives :
  • switch en tant qu'énoncé
  • switch en tant qu'expression
• Travail sur la PFI

Les exemples vus en classe sont les suivants.

Sélectives – exemple 0

while (true)
   Console.WriteLine(Identifier(Console.ReadKey(true).KeyChar));

// piark-e
static string Identifier(char c)
{
   string message;
   switch (char.ToUpper(c))
   {
      case 'A':
      case 'B':
      case 'C':
      // etc.
      case 'Z':
         message = $"'{c}' : Lettre";
         break;
      case '0':
      case '1':
      // etc.
      case '9':
         message = $"'{c}' : Chiffre";
         break;
      case '.':
      case ',':
      // etc.
      case '#':
         message = $"'{c}' : Ponctuation";
         break;
      default:
         message = $"'{c}' : Autre";
         break;
   }
   return message;
}

Sélectives – exemple 1

while (true)
   Console.WriteLine(Identifier(Console.ReadKey(true).KeyChar));

static string Identifier(char c)
{
   string message = "";
   if (char.IsDigit(c))
      message = $"'{c}' : Chiffre";
   else if (char.IsLetter(c))
      message = $"'{c}' : Lettre";
   else if (char.IsPunctuation(c))
      message = $"'{c}' : Ponctuation";
   else
      message = $"'{c}' : Autre";
   return message;
}

 Sélectives – exemple 2

while (true)
   Console.WriteLine(ExprimerDirection(LireDirection()));

static string ExprimerDirection(Direction dir)
{
   switch (dir)
   {
      case Direction.Droite: return "Vers la droite";
      case Direction.Haut: return "Vers le haut";
      case Direction.Gauche: return "Vers la gauche";
      case Direction.Bas: return "Vers le bas";
      default:
         return "Direction inconnue";
   }
}

static Direction LireDirection()
{
   switch (Console.ReadKey(true).Key)
   {
      case ConsoleKey.RightArrow: return Direction.Droite;
      case ConsoleKey.UpArrow: return Direction.Haut;
      case ConsoleKey.LeftArrow: return Direction.Gauche;
      case ConsoleKey.DownArrow: return Direction.Bas;
   }
   // peut être sous default si vous préférez
   throw new DirectionIllégaleException();
}

class DirectionIllégaleException : Exception { }
enum Direction { Droite, Haut, Gauche, Bas }

 Sélectives – exemple 3

while (true)
   Console.WriteLine(ExprimerDirection(LireDirection()));

static string ExprimerDirection(Direction dir)
{
   string[] messages = new[]
   {
      "Vers la droite",
      "Vers le haut",
      "Vers la gauche",
      "Vers le bas"
   };
   return Direction.Droite <= dir && dir <= Direction.Bas ?
      messages[(int)dir] : "Direction inconnue";
}

static Direction LireDirection()
{
   switch (Console.ReadKey(true).Key)
   {
      case ConsoleKey.RightArrow: return Direction.Droite;
      case ConsoleKey.UpArrow: return Direction.Haut;
      case ConsoleKey.LeftArrow: return Direction.Gauche;
      case ConsoleKey.DownArrow: return Direction.Bas;
   }
   // peut être sous default si vous préférez
   throw new DirectionIllégaleException();
}

class DirectionIllégaleException : Exception { }
enum Direction { Droite, Haut, Gauche, Bas }

 Sélectives – exemple 4

while (true)
   Console.WriteLine(ExprimerDirection(LireDirection()));

static string ExprimerDirection(Direction dir) =>
   dir switch
   {
      Direction.Droite => "Vers la droite",
      Direction.Haut => "Vers le haut",
      Direction.Gauche => "Vers la gauche",
      Direction.Bas => "Vers le bas",
      _ => "Direction inconnue"
   };

static Direction LireDirection() =>
   Console.ReadKey(true).Key switch
   {
      ConsoleKey.RightArrow => Direction.Droite,
      ConsoleKey.UpArrow => Direction.Haut,
      ConsoleKey.LeftArrow => Direction.Gauche,
      ConsoleKey.DownArrow => Direction.Bas,
      _ => throw new DirectionIllégaleException()
   };

class DirectionIllégaleException : Exception { }
enum Direction { Droite, Haut, Gauche, Bas }

16 mai

S28

Au menu :

• Travail sur la PFI

18 mai

S29

Au menu :

• Travail sur la PFI

23 mai

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