Affectation

L’opérateur d’affectation est défini sur les structures (struct) du langage C. Il est donc possible d’écrire un code qui effectue une affectation entre deux variables de type struct set. Prenons comme exemple le code ci-dessous (télécharger: affectation.c)

#include <stdio.h>

#include "set.h"

#if defined SENTINEL
#include "set_sentinel.h"
#elif defined DYNAMIC
#include "set_dynamic.h"
#elif defined LINK
#include "set_link.h"
#else
#error "A set implementation has to be defined"
#endif

int main () {
  printf("creation de s1 avec 5 elements\n");
  struct set s1 = set__empty();

  set__add(&s1, 111);
  set__add(&s1, 222);
  set__add(&s1, 333);
  set__add(&s1, 444);
  set__add(&s1, 555);

  struct set s2 = set__empty();

  printf("affectation : s2 = s1\n");
  s2 = s1;
  printf("s2 nb element:resultat (5) -> %zu\n", set__size(&s2));
 
  printf("\najouter 9 dans s1\n");
  set__add(&s1, 9);

  printf("9 dans s2:resultat (NON) -> %s\n", set__find(&s2, 9)? "OUI" : "NON");
  printf("s2 nb elements:resultat (5) -> %zu\n", set__size(&s2));

  set__free(&s1);
  //set__free(&s2);
  return 0;
}

Nous voulons étudier le résultat des deux appels set__find(&s2, 9) et set__size(&s2) après l’ajout d’un élément dans s1 pour chacune des mises en œuvre de set.

Le programme affectation.c utilise la compilation conditionnelle pour inclure le fichier en-tête de la mise en œuvre de set. Le choix du fichier est effectué à la compilation à l’aide du flag -D. Par exemple pour compiler ce programme avec l’implémentation “tableau avec sentinelle”:

gcc -DSENTINEL -c affectation.c

Vous trouverez en annexe les règles à ajouter à votre fichier Makefile pour compiler affectation.c avec chacune des mises en œuvre de struct set.

Exécution

  1. Ajouter le fichier affectation.c dans le répertoire set
  2. Générer trois exécutables de ce programme pour les trois mises en œuvre de set: af_sentinel, af_dynamic et af_link.
  3. Noter les résultats pour chaque mise en œuvre.

Mise en œuvre sentinel

Pour la mise en œuvre du tableau statique avec une butée:

  1. Sur un schéma, montrer ce qui se passe en mémoire lors de l’affectation.
  2. Expliquer le résultat observé.

Mise en œuvre dynamic

Pour la mise en œuvre avec le tableau dynamique sans butée:

  1. Sur un schéma, montrer ce qui se passe en mémoire à l’affectation.
  2. Expliquer le résultat observé.
  3. Décommenter l’instruction set__free(&s2); à la fin de la fonction main(), compiler, exécuter. Expliquer le comportement observé.

Pour la mise en œuvre avec la structure chaînée link:

  1. Sur un schéma, montrer ce qui se passe en mémoire à l’affectation.
  2. Expliquer le résultat observé.
  3. Décommenter l’instruction set__free(&s2); à la fin de la fonction main(), compiler, exécuter. Expliquer le comportement observé.

Annexe

Voici les règles à ajouter à votre fichier Makefile pour compiler le fichier affectation.c avec chacune vos mises en œuvre (attention aux tabulations).

af_sentinel: ${SET_DIR}/affectation.c set_sentinel.o
	${CC} ${CPPFLAGS} ${CFLAGS} -D SENTINEL $< -o affectation.o -c
	${CC} ${CPPFLAGS} ${CFLAGS} set_sentinel.o affectation.o -o $@

af_dynamic: ${SET_DIR}/affectation.c set_dynamic.o
	${CC} ${CPPFLAGS} ${CFLAGS} -D DYNAMIC $< -o affectation.o -c
	${CC} ${CPPFLAGS} ${CFLAGS} set_dynamic.o affectation.o -o $@

af_link: ${SET_DIR}/affectation.c link.o set_link.o
	${CC} ${CPPFLAGS} ${CFLAGS} -D LINK $< -o affectation.o -c
	${CC} ${CPPFLAGS} ${CFLAGS} link.o set_link.o affectation.o -o $@