:: Enseignements :: ESIPE :: E3INFO :: 2010-2011 :: Programmation C ::

Structures, listes chaînées et entrées-sorties

Dans ce TD, nous aborderons les notions de structures, listes chaînées et entrées-sorties. Plus précisément, nous allons travailler sur des listes chaînées de nombres complexes.

Exercice 1 - Nombres complexes

Ecrire, dans un fichier complex.h, la définition d'un nombre complexe sous la forme d'un type structuré. Déclarer également les prototypes des fonctions suivantes :
- new_complex qui crée un nombre complexe en prenant les parties réelle et imaginaire comme paramètres ;
- print_complex qui affiche, sur la sortie standard, un nombre complexe de la façon suivante : la partie réelle suivie d'un espace puis de la partie imaginaire ;
- sum qui calcule la somme de deux nombres complexes ;
- conjugate qui calcule le conjugué d'un nombre complexe ;
- norm qui calcule la norme d'un nombre complexe.
Implémenter dans un fichier complex.c, les fonctions précédentes. Tester votre code en créant un fichier main.c où seront implémentés des tests. Ne pas oublier de faire un Makefile pour compiler vos sources.

Exercice 2 - Listes chaînées de nombres complexes

Le but de cette exercice est d'implémenter un certain nombre d'opérations sur des listes de nombres complexes, en utilisant le module défini dans la question précédente. Nous supposons que nous avons un tableau memory contenant des cellules de listes. Il s'agit d'abord de définir une structure cell qui contient deux champs : une valeur complexe (value) et l'indice dans memory de la cellule suivante (next). Une liste est définie par un indice d'une cellule du tableau memory qui sera la première cellule de la liste. Le champ next pourra avoir deux valeurs particulières, en plus de positions dans le tableau memory:

END (-1) indiquant que la cellule courante n'a pas de cellule suivante.
EMPTY (-2) indiquant que la cellule n'appartient à aucune chaîne (pas de valeur et pas de cellule suivante).

Le tableau memory sera déclaré en global. A chaque fois que l'on voudra ajouter une nouvelle cellule dans une liste, celle-ci correspondra à la première cellule disponible dans le tableau memory (cellule avec champ next égal à EMPTY). On donnera à ses deux champs les valeurs que l'on souhaite.

Ecrire, dans un fichier list.h, la définition d'une liste chaînée de nombres complexes. Déclarer également les prototypes des fonctions suivantes :
- init_memory qui initialise le tableau memory;
- print_memory qui affiche le contenu du tableau memory;
- add qui ajoute un nombre complexe en tête d'une liste ;
- remove_first qui supprime la première cellule d'une liste ;
- print_list qui affiche une liste sur la sortie standard (un nombre complexe par ligne) ;
Implémenter ces fonctions dans un fichier list.c. Ecrire des tests dans le fichier main.c. Ne pas oublier de modifier votre Makefile. Utiliser une constante pour la taille du tableau memory! Ne pas oublier d'initialiser memory!
Ecrire un programme qui crée une liste chaînée de 5 nombres complexes tirés aléatoirement, puis, l'affiche. Les parties réelles et imaginaires devront être comprises entre 0.0 et 20.0. Afficher le tableau memory. Que constatez-vous?
Ecrire un programme qui crée aléatoirement une liste l1 puis une autre l2. Supprimer trois cellules de l1, puis ajouter une cellule à l2 et enfin ajouter une cellule à l1. Afficher memory à chaque étape du programme. Qu'observez-vous?
Ecrire un programme qui calcule la somme des conjugués des nombres complexes d'une liste.
Indication technique : déclarer dans list.h et implémenter dans list.c les fonctions get_complex et get_next. Ces deux fonctions prennent un entier pos en argument. Elles renvoient respectivement les champs value et next de la cellule à l'indice pos dans le tableau memory.
Ecrire un programme qui calcule la norme de la somme des nombres complexes dont la norme est supérieure à 10.

Exercice 3 - Listes chaînées et entrées-sorties

Implémenter une fonction qui sauvegarde une liste de nombres complexes dans un fichier. Reprendre le formatage d'un affichage sur la sortie standard.
Ecrire un programme qui prend comme argument un nom de fichier. Le programme sauvegardera dans le fichier une liste de nombres complexes tirés aléatoirement. Si l'argument est absent, le programme affichera la liste sur la sortie standard.
Implémenter une fonction qui charge une liste de nombres complexes en mémoire depuis un fichier.
Ecrire un programme qui prend comme argument un nom de fichier contenant une liste de nombres complexes au format défini ci-dessus. Le programme chargera la liste en mémoire depuis ce fichier, puis affichera la moyenne des normes des nombres complexes de la liste. Si l'argument est absent, le programme lira la liste sur l'entrée standard. Penser à gérer les erreurs potentielles : en gros, le programme ne doit pas boguer quelque soit l'entrée !
A l'aide des deux programmes précédents qui seront combinés à l'aide d'un pipe, générer aléatoirement une liste de nombres complexes puis afficher la moyenne des normes.

Exercice 4 - Liste chaînée triée de nombres complexes

On souhaite maintenant travailler sur une liste chaînée triée de nombres complexes. On trie les nombres complexes selon leur norme.

Ecrire une fonction add_sorted qui ajoute un nombre complexe dans une liste triée. Tester.
Ecrire une fonction belong qui indique si un nombre complexe appartient à la liste.
Ecrire une fonction extract qui extrait d'une liste de nombres complexes la liste des nombres dont la norme est compris dans un intervalle passé en paramètre.
Ecrire une fonction remove_sorted qui supprime tous les nombres complexes d'une liste qui ont une certaine norme.
Ecrire une fonction qui supprime d'une liste tous les nombres complexes dont la norme est supérieure à 10.