Bonjour,
Pour ceux qui ont fait le second « homework », je viens de mettre les notes dans Moodle et vais vous envoyer sous peu vos copies corrigées par email. Je vous fais également part ici des commentaires généraux.
Concernant les notes publiées dans Moodle :
- Les notes publiées correspondent à la fraction que vous avez obtenue, multipliée par 100 : par exemple pour cet exercice noté, cela correspond à
100 * votre total / 74
car l'épreuve a été notée sur 74 points hors bonus. - La note «Note Finale (SAC)» correspond à la note arrondie, sur l'échelle habituelle 1-6 au quart de point, que vous auriez si on arrêtait là. Je la remettrai à jour après l'examen, suivant les pondérations indiquées dans mon message du 5 mai.
- La note «Total du cours» est calculée automatiquement par Moodle et correspond à la fraction moyenne, laquelle est arrondie pour calculer la note "Finale (SAC)" mentionnée ci-dessus. (> 55% = 4, > 60% = 4.25, etc.)
Commentaires généraux :
C'est à nouveau un devoir très bien réussi (99% de réussite ; points allant de 34.5 à 77.5 sur 74 (hors bonus), moyenne à 67.8 points, médiane à 69 points).
Globalement les bases de l'utilisation des pointeurs semblent maîtrisées et
beaucoup d'étudiants vérifient l'overflow pour le realloc et ont mis le const dans queue_node_t;
mis à part quelques rares cas, tous ont correctement compris comment définir les types queue_t, queue_node_t et priority_queue_t. Les rares qui ont eu un peu de peine à les manipuler sont ceux qui ont voulu mettre un queue_node_t « sentinel/fantôme » de base dans toutes les files.
Voici néanmoins plusieurs remarques pour encore vous améliorer :
* Il y a malgré tout pas mal de fuite mémoire et pertes de pointeurs
* Par exemple, beaucoup d'étudiants utilisent pas correctement réalloc: « ptr = realloc (ptr) », sans vérification (dans certains des cas) ni sauvegarde du pointeur précédent (dans une bonne partie des cas).
* quelques étudiants utilisent des allocations (sans raison presque), pour « initialiser » des pointeurs (au lieu de p.ex. simplement les mettre a NULL).
Nous avons même eu cette « perle » :
if (q != NULL) {
q->first_elt = malloc(sizeof(queue_node_t));
q->first_elt = NULL;
q->last_elt = malloc(sizeof(queue_node_t));
q->last_elt = NULL;
}
Bonjour la fuite de mémoire gratuite !
* il reste aussi une certaine tendance (chez certains) à ne pas
contrôler les retour de fonctions, surtout celles d’allocation
dynamique de mémoire (calloc, malloc et realloc).
* Certains etudiants font systématiquement des copies des structures passé en argument, modifient les copies puis recopient les modification dans le pointeur passé en argument (alors que c'est pas toujours nécéssaire ; c'est bien de le faire si il y a risque d'échec en cours de route [et si la structure n'est pas trop grosse à copier]).
* encore trop de boucles sur des int au lieu de size_t
* absences de robustesse par manque de vérification des paramètres (pointeurs déréférencés sans être testés),
* beaucoup trop d'étudiants écrivent des choses telles que :
+
+
alors que juste «
+ Quelques étudiants ont implémenté task_t comme étant un « void * » mais malheureusement sans adapter le code fourni
Globalement les bases de l'utilisation des pointeurs semblent maîtrisées et
beaucoup d'étudiants vérifient l'overflow pour le realloc et ont mis le const dans queue_node_t;
mis à part quelques rares cas, tous ont correctement compris comment définir les types queue_t, queue_node_t et priority_queue_t. Les rares qui ont eu un peu de peine à les manipuler sont ceux qui ont voulu mettre un queue_node_t « sentinel/fantôme » de base dans toutes les files.
Voici néanmoins plusieurs remarques pour encore vous améliorer :
* Il y a malgré tout pas mal de fuite mémoire et pertes de pointeurs
* Par exemple, beaucoup d'étudiants utilisent pas correctement réalloc: « ptr = realloc (ptr) », sans vérification (dans certains des cas) ni sauvegarde du pointeur précédent (dans une bonne partie des cas).
* quelques étudiants utilisent des allocations (sans raison presque), pour « initialiser » des pointeurs (au lieu de p.ex. simplement les mettre a NULL).
Nous avons même eu cette « perle » :
if (q != NULL) {
q->first_elt = malloc(sizeof(queue_node_t));
q->first_elt = NULL;
q->last_elt = malloc(sizeof(queue_node_t));
q->last_elt = NULL;
}
Bonjour la fuite de mémoire gratuite !
* il reste aussi une certaine tendance (chez certains) à ne pas
contrôler les retour de fonctions, surtout celles d’allocation
dynamique de mémoire (calloc, malloc et realloc).
* Certains etudiants font systématiquement des copies des structures passé en argument, modifient les copies puis recopient les modification dans le pointeur passé en argument (alors que c'est pas toujours nécéssaire ; c'est bien de le faire si il y a risque d'échec en cours de route [et si la structure n'est pas trop grosse à copier]).
* encore trop de boucles sur des int au lieu de size_t
* absences de robustesse par manque de vérification des paramètres (pointeurs déréférencés sans être testés),
* beaucoup trop d'étudiants écrivent des choses telles que :
+
return (a==b)?1:0
+
if(a==b) return 1; else return 0;
alors que juste «
return a == b;
» suffirait !+ Quelques étudiants ont implémenté task_t comme étant un « void * » mais malheureusement sans adapter le code fourni
